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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/boraboreal.py : Bora Boréal (boraboreal.com) — chalets FLOTTANTS
++#   (minibora, boravilla) à Bury (Cantons-de-l'Est) et à Québec, plus un
++#   chalet en bois rond ; ~13 unités réservables sur Lodgify
++#   (reserver-boraboreal.lodgify.com, protégé Cloudflare → Scrapfly).
++#
++# Méthode :
++#   1. SLUGS : le sitemap Lodgify est vide → la page « louer-maison-flottante »
++#      (rendue via Scrapfly, la grille est en JS) liste les 12 chalets
++#      flottants ; les pages vitrines boraboreal.com (récupérées en direct)
++#      ajoutent les unités hors grille (bora-bois-rond).
++#   2. DÉTAIL : chaque page unité Lodgify (Scrapfly sans render_js, cache
++#      détail « v1 ») embarque un JSON-LD VacationRental complet :
++#      identifier (external_id), priceRange « from 229 CAD/night »,
++#      occupancy/chambres, amenityFeature, adresse, geo lat/lng, ~19 photos
++#      icdbcdn ; le CITQ est extrait de la description (au-delà de la fenêtre
++#      de 2000 caractères de finalize()). Animaux : frais au séjour
++#      → pets = « conditions » si l'amenité l'indique.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import json
++import re
++import sys
++
++from ..schema import StListing
++from .airbnb import _region_from_latlng
++from .base import StConnector
++
++BOOKING = "https://reserver-boraboreal.lodgify.com"
++GRID = BOOKING + "/fr/louer-maison-flottante"
++
++# pages vitrines boraboreal.com (accessibles en direct) qui pointent vers des
++# unités Lodgify absentes de la grille
++SHOWCASE = [
++    "https://boraboreal.com/chalet-flottant-quebec",
++    "https://boraboreal.com/mini-chalet-a-louer-estrie",
++    "https://boraboreal.com/chalet-6-personnes-estrie",
++]
++
++_TAG_RE = re.compile(r"<[^>]+>")
++
++_LD_RE = re.compile(r'(?s)<script[^>]*type="application/ld\+json"[^>]*>'
++                    r"(.*?)</script>")
++
++
++def _strip_html(txt: str) -> str:
++    txt = re.sub(r"</p>|<br\s*/?>|</li>", "\n", txt or "")
++    txt = _html.unescape(_TAG_RE.sub(" ", txt))
++    txt = re.sub(r"[ \t]+", " ", txt)
++    return re.sub(r"\n\s+", "\n", txt).strip()
++
++
++class BoraBoreal(StConnector):
++    source_id = "boraboreal"
++
++    # -- découverte des slugs --------------------------------------------------
++    def _slugs(self) -> list[str]:
++        slugs: list[str] = []
++
++        def add(s: str):
++            s = s.strip("/")
++            if s and s != "louer-maison-flottante" and s not in slugs:
++                slugs.append(s)
++
++        try:
++            grid = self.get_scrapfly(GRID, render_js=True,
++                                     rendering_wait=3000)
++            for s in re.findall(r'href="(?:%s)?/fr/([\w~-]+)"'
++                                % re.escape(BOOKING), grid):
++                add(s)
++        except Exception as exc:  # noqa: BLE001
++            print(f"[boraboreal] grille : {exc}", file=sys.stderr)
++
++        for page in SHOWCASE:
++            try:
++                h = self.get(page).text
++            except Exception:  # noqa: BLE001
++                continue
++            for s in re.findall(
++                    r"reserver-boraboreal\.lodgify\.com/(?:fr/)?([\w~-]+)", h):
++                add(s)
++        return slugs
++
++    # -- page unité Lodgify ----------------------------------------------------
++    def _detail(self, slug: str) -> dict:
++        h = self.get_scrapfly(f"{BOOKING}/fr/{slug}", render_js=False)
++        for block in _LD_RE.findall(h):
++            try:
++                ld = json.loads(block)
++            except ValueError:
++                continue
++            if ld.get("@type") == "VacationRental":
++                return {"ld": ld}
++        return {}
++
++    # -- contrat ---------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        listings: list[StListing] = []
++        vus: set[str] = set()
++        for slug in self._slugs():
++            det = self.detail(slug, "v1", lambda s=slug: self._detail(s))
++            ld = det.get("ld") or {}
++            if not ld:
++                continue
++            ext_id = str(ld.get("identifier") or slug)
++            if ext_id in vus:
++                continue
++            vus.add(ext_id)
++
++            place = ld.get("containsPlace") or {}
++            occupancy = (place.get("occupancy") or {}).get("value")
++            addr = ld.get("address") or {}
++            geo = ld.get("geo") or {}
++
++            # « from 229 CAD/night » → price_night
++            price = None
++            m = re.search(r"from\s+([\d.]+)\s*CAD",
++                          str(ld.get("priceRange") or ""))
++            if m:
++                v = float(m.group(1))
++                if 20 <= v <= 20000:
++                    price = v
++
++            description = _strip_html(str(ld.get("description") or ""))
++            m = re.search(r"CITQ\D{0,25}(\d{6})", description)
++            citq = m.group(1) if m else ""
++
++            amen = [a.get("name") for a in ld.get("amenityFeature") or []
++                    if isinstance(a, dict) and a.get("name")
++                    and a.get("value") is not False]
++            pets = "conditions" if any("animaux" in a.lower()
++                                       or "pet" in a.lower()
++                                       for a in amen) else None
++
++            imgs = ld.get("image") or []
++            if isinstance(imgs, str):
++                imgs = [imgs]
++
++            city = (addr.get("addressLocality") or "").strip()
++            region = (_region_from_latlng(geo.get("latitude"),
++                                          geo.get("longitude"))
++                      or ("Québec" if slug.endswith("---quebec")
++                          else "Cantons-de-l'Est"))
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=ext_id,
++                url=f"{BOOKING}/fr/{slug}",
++                title=_html.unescape(str(ld.get("name") or slug)).strip(),
++                property_type="Chalet",
++                address=(addr.get("streetAddress") or "").strip(),
++                city=city,
++                region=region,
++                price_night=price,
++                price_label=(f"à partir de {price:g} $ / nuit"
++                             if price else ""),
++                capacity=float(occupancy) if occupancy else None,
++                bedrooms=(float(place["numberOfBedrooms"])
++                          if place.get("numberOfBedrooms") else None),
++                pets=pets,
++                citq=citq,
++                description=description[:5000],
++                amenities=amen,
++                details={"floating": "bois-rond" not in slug,
++                         "postal_code": addr.get("postalCode") or ""},
++                images=[u for u in imgs if isinstance(u, str)
++                        and u.startswith("https://")][:20],
++                lat=geo.get("latitude"),
++                lng=geo.get("longitude"),
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/campingquebec.py : Camping Québec (campingquebec.com) —
++# l'association des ~830 terrains de camping du Québec. On ne retient QUE
++# les campings offrant du PRÊT-À-CAMPER / hébergement locatif (tentes
++# aménagées, chalets, yourtes, roulottes…) : un camping « emplacements
++# seulement » n'est pas un hébergement court terme pour Lou-Ka.
++#
++# Méthode (WordPress, aucun anti-bot) :
++#   1. LISTE : l'endpoint AJAX de « Trouver un camping » est ouvert :
++#      GET /fr/wp-json/search/result?lang=fr&view=list
++#          &ready_to_camps[]=tous-types-de-pret-a-camper-disponible&paged=N
++#      → fragments HTML de 24 cartes/page (~600 campings filtrés prêt-à-camper).
++#      Carte : URL /fr/campings/<région>/<slug> (= external_id), nom, région.
++#   2. FICHE (cache self.detail, clé mensuelle pour suivre les tarifs) :
++#      description, adresse + ville (bloc Informations), coordonnées (lien
++#      google.ca/maps?q=lat,lng), no d'enregistrement CITQ, tarifs (ligne
++#      « Nuitée, Prêt-à-camper » min-max → price_night), unités prêt-à-camper
++#      (« Prêt-à-camper disponibles : Tentes : 2 »), services (amenities),
++#      nb d'emplacements, dates de saison, photos. Garde-fou : la fiche doit
++#      confirmer le prêt-à-camper (unités ou tarif), sinon elle est écartée.
++#
++# Réglage env : LOUKA_CAMPINGQUEBEC_LIMIT (nb max de fiches, 0 = tout).
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import os
++import re
++import sys
++import time
++
++from ..schema import StListing, normalize_region
++from .base import StConnector
++
++SITE = "https://www.campingquebec.com"
++API = f"{SITE}/fr/wp-json/search/result"
++PREFIX_FICHE = f"{SITE}/fr/campings/"
++PAGE_MAX = 60                                  # garde-fou pagination
++
++_MAPS_RE = re.compile(r"google\.ca/maps\?q=(-?\d+\.\d+),(-?\d+\.\d+)")
++_CITQ_RE = re.compile(r"No d[’']enregistrement\s*(\d{5,7})")
++_PAGE_RE = re.compile(r'aria-label="Page (\d+)"')
++_MONTANT_RE = re.compile(r"([\d\s  ]+(?:[.,]\d{2})?)\s*\$")
++
++# Libellé d'unité prêt-à-camper → type canonique Lou-Ka (si type unique) ;
++# le préfixe « location de » est retiré avant consultation.
++_TYPE_UNITE = {
++    "tente": "Prêt-à-camper", "tentes": "Prêt-à-camper",
++    "chalet": "Chalet", "chalets": "Chalet",
++    "yourte": "Yourte", "yourtes": "Yourte",
++    "dôme": "Dôme", "dômes": "Dôme", "bulle ou dôme": "Dôme",
++    "refuge": "Refuge", "refuges": "Refuge",
++    "tipi": "Prêt-à-camper", "tipis": "Prêt-à-camper",
++    "cabine": "Prêt-à-camper", "cabines": "Prêt-à-camper",
++    "caravane": "Prêt-à-camper", "caravanes": "Prêt-à-camper",
++}
++
++
++def _montant(txt: str) -> float | None:
++    m = _MONTANT_RE.search(txt or "")
++    if not m:
++        return None
++    try:
++        return float(re.sub(r"[\s  ]", "", m.group(1)).replace(",", "."))
++    except ValueError:
++        return None
++
++
++class CampingQuebec(StConnector):
++    source_id = "campingquebec"
++    request_delay = 0.8
++
++    # -- liste (fragments HTML paginés) ----------------------------------------
++    def _liste(self, limit: int = 0) -> list[dict]:
++        from bs4 import BeautifulSoup
++        items, vus = [], set()
++        page, total_pages = 1, 1
++        while page <= min(total_pages, PAGE_MAX):
++            if limit and len(items) >= limit:
++                break
++            html = self.get(API, params={
++                "lang": "fr", "view": "list",
++                "ready_to_camps[]": "tous-types-de-pret-a-camper-disponible",
++                "paged": page,
++            }).text
++            pages = [int(p) for p in _PAGE_RE.findall(html)]
++            if pages:
++                total_pages = max(pages)
++            soup = BeautifulSoup(html, "html.parser")
++            nouveaux = 0
++            for a in soup.select(f'a.c-card[href^="{PREFIX_FICHE}"]'):
++                path = a["href"][len(PREFIX_FICHE):].strip("/")
++                if path.count("/") != 1 or path in vus:
++                    continue
++                vus.add(path)
++                nouveaux += 1
++                h4 = a.find("h4")
++                span = a.select_one("span.u-text-transform-none")
++                items.append({
++                    "id": path,                       # <région>/<slug>
++                    "nom": h4.get_text(" ", strip=True) if h4 else "",
++                    "region": span.get_text(" ", strip=True) if span else "",
++                })
++            if not nouveaux:                          # page vide → fin
++                break
++            page += 1
++        return items
++
++    # -- fiche camping ----------------------------------------------------------
++    def _fetch_fiche(self, path: str) -> dict:
++        from bs4 import BeautifulSoup
++        html = self.get(PREFIX_FICHE + path).text
++        soup = BeautifulSoup(html, "html.parser")
++        d: dict = {}
++
++        m = _MAPS_RE.search(html)
++        if m:
++            d["lat"], d["lng"] = float(m.group(1)), float(m.group(2))
++        m = _CITQ_RE.search(html)
++        if m:
++            d["citq"] = m.group(1)
++
++        # description : bloc typographique sous l'en-tête « Description »
++        for div in soup.find_all("div"):
++            if div.get_text(strip=True) == "Description":
++                typo = div.find_next_sibling("div")
++                if typo is not None:
++                    d["description"] = typo.get_text("\n", strip=True)[:2500]
++                break
++
++        # adresse + ville : paragraphe précédant « Voir sur la carte »
++        carte = soup.find("a", string=re.compile("Voir sur la carte"))
++        if carte is None:
++            for a in soup.find_all("a"):
++                if "Voir sur la carte" in a.get_text():
++                    carte = a
++                    break
++        if carte is not None:
++            p = carte.find_previous("p")
++            if p is not None:
++                lignes = [x.strip() for x in p.get_text("\n").split("\n")
++                          if x.strip()]
++                if lignes:
++                    d["adresse"] = ", ".join(lignes)
++                    # « Saint-Sulpice J5W 3V5 » → ville sans le code postal
++                    d["ville"] = re.sub(
++                        r"\s*[A-Z]\d[A-Z]\s*\d[A-Z]\d\s*$", "",
++                        lignes[-1]).strip(" ,")
++
++        # sections h4 → listes (unités PAC, emplacements…)
++        sections: dict[str, list[str]] = {}
++        for h4 in soup.find_all("h4"):
++            titre = h4.get_text(" ", strip=True)
++            parent = h4.find_parent("div")
++            bloc = parent.find_next_sibling("div") if parent else None
++            if bloc is not None:
++                lis = [li.get_text(" ", strip=True)
++                       for li in bloc.find_all("li")]
++                if lis:
++                    sections[titre] = lis
++
++        pac: dict[str, int] = {}
++        for titre, lis in sections.items():
++            if titre.lower().startswith("prêt-à-camper"):
++                for li in lis:
++                    nom, _, nb = li.partition(":")
++                    try:
++                        pac[nom.strip()] = int(nb.strip())
++                    except ValueError:
++                        pac[nom.strip()] = 0
++        d["pac"] = pac
++        for titre, lis in sections.items():
++            if titre.lower().startswith("types d'emplacements"):
++                d["emplacements"] = lis[:12]
++
++        # tarifs : lignes de la table « Durée / Min. / Max. »
++        for tr in soup.select("table.c-table tr"):
++            tds = [td.get_text(" ", strip=True) for td in tr.find_all("td")]
++            if len(tds) >= 2 and "prêt-à-camper" in tds[0].lower():
++                d["tarif_pac_min"] = _montant(tds[1])
++                d["tarif_pac_max"] = _montant(tds[2]) if len(tds) > 2 else None
++            elif len(tds) >= 2 and tds[0].lower() == "nuitée":
++                d["tarif_nuit_min"] = _montant(tds[1])
++
++        # services offerts → amenities (panneau d'accordéon « services »)
++        panneau = soup.select_one(
++            'div.c-accordion__target[data-toggler-target*="services"]')
++        if panneau is not None:
++            d["services"] = [li.get_text(" ", strip=True)
++                             for li in panneau.find_all("li")][:40]
++
++        # saison
++        texte = soup.get_text(" ", strip=True)
++        m = re.search(r"Date d['’]ouverture\s*:\s*([\d]{1,2} \S+ \d{4})", texte)
++        if m:
++            d["ouverture"] = m.group(1)
++        m = re.search(r"Date de fermeture\s*:\s*([\d]{1,2} \S+ \d{4})", texte)
++        if m:
++            d["fermeture"] = m.group(1)
++
++        # photos (galerie WordPress, en excluant logos et gabarits)
++        imgs: list[str] = []
++        for img in soup.find_all("img"):
++            u = img.get("data-lazy-src") or img.get("src") or ""
++            if (u.startswith(f"{SITE}/wp-content/uploads/20")
++                    and "logo" not in u.lower() and u not in imgs):
++                imgs.append(u)
++        d["images"] = imgs[:12]
++        return d
++
++    # -- contrat ----------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        limit = int(os.environ.get("LOUKA_CAMPINGQUEBEC_LIMIT", "0") or 0)
++        month = time.strftime("%Y-%m")      # re-visite mensuelle (tarifs)
++        listings: list[StListing] = []
++        # marge : certaines fiches de la liste seront écartées au garde-fou
++        for it in self._liste(limit * 3 if limit else 0):
++            path = it["id"]
++            try:
++                d = self.detail(path, month,
++                                lambda p=path: self._fetch_fiche(p))
++            except Exception as exc:  # noqa: BLE001
++                print(f"[campingquebec] fiche {path} : {exc}", file=sys.stderr)
++                continue
++
++            pac = d.get("pac") or {}
++            prix_pac = d.get("tarif_pac_min")
++            if not pac and not prix_pac:     # aucun hébergement locatif confirmé
++                continue
++
++            price_label = ""
++            if prix_pac:
++                pmax = d.get("tarif_pac_max")
++                price_label = (f"prêt-à-camper {prix_pac:.2f} $"
++                               + (f" à {pmax:.2f} $" if pmax else "")
++                               + " / nuit")
++
++            # type : celui de l'unique famille d'unités, sinon Prêt-à-camper
++            ptype = "Prêt-à-camper"
++            if len(pac) == 1:
++                libelle = re.sub(r"^location (de |d')", "",
++                                 next(iter(pac)).lower()).strip()
++                ptype = _TYPE_UNITE.get(libelle, ptype)
++
++            details = {k: v for k, v in {
++                "unites_pret_a_camper": pac or None,
++                "emplacements": d.get("emplacements"),
++                "tarif_emplacement_min": d.get("tarif_nuit_min"),
++                "ouverture": d.get("ouverture", ""),
++                "fermeture": d.get("fermeture", ""),
++            }.items() if v}
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=path,
++                url=PREFIX_FICHE + path,
++                title=it.get("nom") or path.rsplit("/", 1)[-1],
++                property_type=ptype,
++                address=d.get("adresse", ""),
++                city=d.get("ville", ""),
++                region=normalize_region(it.get("region", "")),
++                price_night=prix_pac,
++                price_label=price_label,
++                citq=d.get("citq", ""),
++                description=d.get("description", ""),
++                amenities=d.get("services") or [],
++                details=details,
++                images=d.get("images") or [],
++                lat=d.get("lat"),
++                lng=d.get("lng"),
++            ))
++            if limit and len(listings) >= limit:
++                break
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/captremblant.py : Cap Tremblant Mountain Resort
++#   (captremblant.com) — complexe de résidences de tourisme à Mont-Tremblant.
++#   7 catégories de résidences (1 à 5 chambres), chacune regroupant plusieurs
++#   unités identiques (fiches « catégorie », pas unité par unité).
++#
++# Méthode : sitemap.xml → 7 URLs /residences/<slug> (version fr ; les /en/
++#   sont ignorées). Pas de lastmod → cache détail « v1 ». Chaque page embarque
++#   un JSON-LD @type ["HotelRoom","Product"] : nom, description, image
++#   (galaxy.tf) et offers.price = tarif À LA NUIT en CAD (ex. 251,10 $) →
++#   price_night « à partir de ». La liste des caractéristiques vit dans le
++#   <ul> du bloc <div class="m-content-object--content"> → amenities ;
++#   capacité extraite de « jusqu'à six personnes » (nombres en toutes
++#   lettres), chambres déduites du slug/titre. La galerie est chargée en JS :
++#   seule l'image JSON-LD est disponible statiquement.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import json
++import re
++
++from ..schema import StListing
++from .base import StConnector
++
++SITE = "https://www.captremblant.com"
++SITEMAP = SITE + "/sitemap.xml"
++
++_WORDS = {"un": 1, "une": 1, "deux": 2, "trois": 3, "quatre": 4, "cinq": 5,
++          "six": 6, "sept": 7, "huit": 8, "neuf": 9, "dix": 10, "onze": 11,
++          "douze": 12}
++
++_TAG_RE = re.compile(r"<[^>]+>")
++
++
++def _text(fragment: str) -> str:
++    return _html.unescape(re.sub(r"\s+", " ", _TAG_RE.sub(" ", fragment))).strip()
++
++
++def _count(txt: str) -> int | None:
++    """« six » ou « 6 » → 6."""
++    t = txt.strip().lower()
++    if t.isdigit():
++        return int(t)
++    return _WORDS.get(t)
++
++
++class CapTremblant(StConnector):
++    source_id = "captremblant"
++    request_delay = 0.8
++
++    # -- page détail ----------------------------------------------------------
++    def _detail(self, url: str) -> dict:
++        h = self.get(url).text
++        d: dict = {}
++
++        for block in re.findall(r'<script type="application/ld\+json"[^>]*>'
++                                r"(.*?)</script>", h, re.S):
++            try:
++                ld = json.loads(block)
++            except ValueError:
++                continue
++            types = ld.get("@type")
++            types = types if isinstance(types, list) else [types]
++            if "HotelRoom" in types or "Product" in types:
++                d["ld"] = ld
++                break
++
++        # caractéristiques : <ul> du bloc m-content-object--content
++        m = re.search(r'(?s)<div class="m-content-object--content[^"]*"[^>]*>'
++                      r"(.*?)</div>", h)
++        if m:
++            amen = []
++            for li in re.findall(r"(?s)<li[^>]*>(.*?)</li>", m.group(1)):
++                t = _text(li)
++                if t and t not in amen:
++                    amen.append(t)
++            if amen:
++                d["amenities"] = amen
++        return d
++
++    # -- contrat --------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        xml = self.get(SITEMAP).text
++        urls = [u for u in re.findall(r"<loc>([^<]+)</loc>", xml)
++                if "/residences/" in u and "/en/" not in u]
++
++        listings: list[StListing] = []
++        vus: set[str] = set()
++        for url in urls:
++            slug = url.rstrip("/").split("/")[-1]
++            if slug in vus:
++                continue
++            vus.add(slug)
++
++            det = self.detail(slug, "v1", lambda u=url: self._detail(u))
++            ld = det.get("ld") or {}
++            if not ld:
++                continue
++
++            title = _text(str(ld.get("name") or slug))
++            amen = det.get("amenities") or []
++            description = _text(str(ld.get("description") or ""))
++            if amen and len(" ".join(amen)) > len(description):
++                description = description or " ".join(amen[:1])
++
++            # capacité : « jusqu'à six personnes » / « de dix à douze
++            # personnes » (description ou 1re puce) — on prend le maximum
++            capacity = None
++            hay = f"{description} {' '.join(amen[:2])}"
++            m = (re.search(r"jusqu[’']à\s+(\w+)\s+personnes", hay, re.I)
++                 or re.search(r"de\s+\w+\s+à\s+(\w+)\s+personnes", hay, re.I))
++            if m:
++                capacity = _count(m.group(1))
++
++            # chambres : déduites du slug/titre (« deux-chambres », « cinq… »)
++            bedrooms = None
++            m = re.search(r"(\w+)[- ]chambres?", f"{slug} {title}".lower())
++            if m:
++                bedrooms = _count(m.group(1))
++
++            price = None
++            try:
++                price = float((ld.get("offers") or {}).get("price"))
++            except (TypeError, ValueError):
++                pass
++            # garde-fou : la fiche « quatre chambres » publie 29520.00 $
++            # (bogue du site, sans doute 295,20 $) → tarif rejeté
++            if price is not None and not 50 <= price <= 5000:
++                price = None
++            price_label = (f"à partir de {price:g} $ / nuit"
++                           if price else "")
++
++            img = ld.get("image") or ""
++            images = [img] if isinstance(img, str) \
++                and img.startswith("https://") else []
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=slug,
++                url=url,
++                title=title,
++                property_type="Condo",
++                address="240 Rue du Mont-Plaisant, Mont-Tremblant",
++                city="Mont-Tremblant",
++                region="Laurentides",
++                price_night=price,
++                price_label=price_label,
++                capacity=float(capacity) if capacity else None,
++                bedrooms=float(bedrooms) if bedrooms else None,
++                description=description[:3000],
++                amenities=amen,
++                details={"multi_unit": True, "resort": "Cap Tremblant"},
++                images=images,
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/chaleto.py : Chaleto (chaleto.ca) — gestionnaire québécois
++#   (Charlevoix, Capitale-Nationale, Laurentides…), ~440 fiches FR.
++#
++# Méthode : WordPress (vitrine) + Guesty (inventaire). Sitemap dédié
++#   /listings-sitemap.xml → URLs /chalets-et-condos-a-louer/<slug>-<guestyId>/
++#   (doublées en /en/ : on garde le FR). Tout est dans le HTML serveur de la
++#   page détail : h1, « Ville, Région », prix « À partir de N$ / nuit »,
++#   pictos (voyageurs/chambres/lits/salles de bain), commodités, description
++#   (contenant le no CITQ) et TOUTES les photos Guesty pleine résolution dans
++#   l'attribut data-images de la lightbox. Le lastmod du sitemap est identique
++#   partout : clé de cache mensuelle (refetch complet 1×/mois, ~440 requêtes).
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import json
++import re
++import time
++
++from ...normalize import strip_accents
++from ..schema import StListing, parse_price_night
++from .base import StConnector
++
++SITEMAP = "https://chaleto.ca/listings-sitemap.xml"
++
++# URL FR : /chalets-et-condos-a-louer/<slug>-<id Guesty 24 hex>/
++_URL_FR = re.compile(
++    r"https://(?:www\.)?chaleto\.ca/chalets-et-condos-a-louer/"
++    r"[\w-]+-([0-9a-f]{24})/?$")
++
++_TAG_RE = re.compile(r"<[^>]+>")
++
++# le site affiche la région ADMINISTRATIVE (« Capitale-Nationale »,
++# « Gaspésie--Îles-de-la-Madeleine ») → région touristique canonique
++_REGION_FIX = {
++    "capitale-nationale": "Québec",
++    "estrie": "Cantons-de-l'Est",
++    "gaspesie-iles-de-la-madeleine": "Gaspésie",
++    "saguenay-lac-saint-jean": "Saguenay–Lac-Saint-Jean",
++}
++
++# municipalités de la Capitale-Nationale qui relèvent touristiquement
++# de Charlevoix
++_VILLES_CHARLEVOIX = {
++    "baie-saint-paul", "petite-riviere-saint-francois", "la-malbaie",
++    "les-eboulements", "saint-urbain", "saint-irenee", "saint-hilarion",
++    "isle-aux-coudres", "l'isle-aux-coudres", "notre-dame-des-monts",
++    "saint-aime-des-lacs", "clermont", "saint-simeon",
++    "baie-sainte-catherine",
++}
++
++# mot-clé du titre → type canonique Lou-Ka
++_TYPE_HINTS = [
++    ("condo", "Condo"), ("loft", "Loft"), ("studio", "Studio"),
++    ("appartement", "Appartement"), ("maison", "Maison"),
++    ("mini-maison", "Mini-maison"), ("chalet", "Chalet"),
++]
++
++
++def _text(fragment: str) -> str:
++    return _html.unescape(re.sub(r"\s+", " ", _TAG_RE.sub(" ", fragment))).strip()
++
++
++class Chaleto(StConnector):
++    source_id = "chaleto"
++
++    # -- inventaire (sitemap) ----------------------------------------------
++    def _sitemap_urls(self) -> dict[str, str]:
++        """id Guesty -> URL détail FR."""
++        xml = self.get(SITEMAP).text
++        urls: dict[str, str] = {}
++        for loc in re.findall(r"<loc>([^<]+)</loc>", xml):
++            m = _URL_FR.match(loc.strip())
++            if m:
++                urls.setdefault(m.group(1), loc.strip())
++        return urls
++
++    # -- page détail ---------------------------------------------------------
++    def _detail(self, url: str) -> dict:
++        h = self.get(url).text
++        d: dict = {}
++
++        m = re.search(r"<h1[^>]*>(.*?)</h1>", h, re.S)
++        if m:
++            d["title"] = _text(m.group(1))
++
++        # « Baie-Saint-Paul, Capitale-Nationale » sous le titre
++        m = re.search(r'<p class="text-lg">([^<]+)</p>', h)
++        if m:
++            parts = [p.strip() for p in _text(m.group(1)).split(",")]
++            if parts:
++                d["city"] = parts[0]
++            if len(parts) > 1:
++                cle = re.sub(r"-{2,}", "-",
++                             strip_accents(parts[-1]).lower().replace(" ", "-"))
++                region = _REGION_FIX.get(cle, parts[-1])
++                ville = strip_accents(d.get("city", "")).lower().replace(" ", "-")
++                if region == "Québec" and ville in _VILLES_CHARLEVOIX:
++                    region = "Charlevoix"
++                d["region"] = region
++
++        # « À partir de <strong>200$</strong> / nuit »
++        m = re.search(r"À partir de</span>\s*<span[^>]*>\s*"
++                      r"<strong>([^<]+)</strong>\s*/\s*nuit", h)
++        if m:
++            d["price_label"] = f"à partir de {_text(m.group(1))} / nuit"
++
++        # pictos : « 5 voyageurs », « 3 chambres », « 3 lits », « 2 salles de bain »
++        for val, label in re.findall(
++                r"<p>\s*([\d.,]+)\s+(voyageurs?|chambres?|lits?|"
++                r"salles? de bain)\s*</p>", h):
++            n = float(val.replace(",", "."))
++            lab = label.lower()
++            if lab.startswith("voyageur"):
++                d["capacity"] = n
++            elif lab.startswith("chambre"):
++                d["bedrooms"] = n
++            elif lab.startswith("lit"):
++                d["beds"] = n
++            else:
++                d["bathrooms"] = n
++
++        # commodités : spans du bloc « Commodités » (grille + accordéon)
++        i = h.find("Commodités</h2>")
++        if i >= 0:
++            j = h.find("<h2", i + 10)
++            bloc = h[i:j if j > 0 else i + 20000]
++            amen = []
++            for a in re.findall(r'<span class="text-white">([^<]+)</span>', bloc):
++                a = _text(a)
++                if a and a not in amen:
++                    amen.append(a)
++            d["amenities"] = amen
++
++        # description (1er paragraphe long — contient « CITQ : NNNNNN | Exp: … »)
++        m = re.search(r'<p class="max-w-\[50rem\]">(.*?)</p>', h, re.S)
++        if m:
++            txt = _html.unescape(re.sub(r"<br\s*/?>", "\n",
++                                        m.group(1)))
++            txt = _TAG_RE.sub(" ", txt)
++            txt = re.sub(r"[ \t]+", " ", txt).strip()
++            d["description"] = txt[:5000]
++            m2 = re.search(r"CITQ\s*:?\s*(\d{6})", txt)
++            if m2:
++                d["citq"] = m2.group(1)
++
++        # photos Guesty pleine résolution (lightbox data-images, JSON échappé)
++        m = re.search(r'data-images="([^"]+)"', h)
++        if m:
++            try:
++                imgs = json.loads(_html.unescape(m.group(1)))
++            except ValueError:
++                imgs = []
++            d["images"] = [u for u in imgs if isinstance(u, str)][:20]
++        return d
++
++    # -- contrat --------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        cle = "detail-" + time.strftime("%Y-%m")   # lastmod uniforme → mensuel
++        listings: list[StListing] = []
++        for eid, url in self._sitemap_urls().items():
++            try:
++                d = self.detail(eid, cle, lambda u=url: self._detail(u))
++            except Exception:      # une fiche cassée ≠ inventaire perdu
++                d = {}
++            title = d.get("title") or ""
++            if not title:
++                continue
++
++            ptype = ""
++            hay = strip_accents(title).lower()
++            for needle, canon in _TYPE_HINTS:
++                if needle in hay:
++                    ptype = canon
++                    break
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=eid,                  # id Guesty, stable
++                url=url,
++                title=title,
++                property_type=ptype or "Chalet",
++                city=d.get("city", ""),
++                region=d.get("region", ""),
++                price_night=parse_price_night(d.get("price_label", "")),
++                price_label=d.get("price_label", ""),
++                capacity=d.get("capacity"),
++                bedrooms=d.get("bedrooms"),
++                beds=d.get("beds"),
++                bathrooms=d.get("bathrooms"),
++                citq=d.get("citq", ""),
++                description=d.get("description", ""),
++                amenities=d.get("amenities") or [],
++                images=d.get("images") or [],
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/chaletsalpins.py : Les Chalets Alpins (chaletsalpins.ca)
++#   — gestionnaire de Stoneham, ~180 chalets (Stoneham, Lac-Beauport,
++#   Charlevoix, Laurentides).
++#
++# Méthode : WordPress. Sitemap /chalets-sitemap.xml (lastmod fiable, doublons
++#   /en/ écartés) → pages /hebergement/<slug>/ (slug = adresse + no CITQ).
++#   La page détail porte un JSON-LD schema.org Hotel (nom, description,
++#   addressLocality, petsAllowed, amenityFeature FR) ; les compteurs vivent
++#   dans des <span class="capacity|bedrooms|beds|restrooms">…N</span> de la
++#   barre d'entête, et le prix dans l'encadré latéral
++#   « <h3>2 nuits à partir de (printemps) <span>1 025.00 $</span></h3> »
++#   (minimum 2 nuits → prix ramené à la nuit). Photos = uploads du carrousel
++#   (vignettes -150x150 écartées). Pas de géo dans le HTML.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import json
++import re
++
++from ...normalize import strip_accents
++from ..schema import StListing
++from .base import StConnector
++
++SITEMAP = "https://chaletsalpins.ca/chalets-sitemap.xml"
++
++_URL_DETAIL = re.compile(
++    r"https://(?:www\.)?chaletsalpins\.ca/hebergement/([\w-]+)/?$")
++
++# localités desservies → région touristique canonique
++_VILLE_REGION = {
++    "stoneham": "Québec",
++    "stoneham-et-tewkesbury": "Québec",
++    "lac-beauport": "Québec",
++    "quebec": "Québec",
++    "petite-riviere-saint-francois": "Charlevoix",
++    "baie-saint-paul": "Charlevoix",
++    "la-malbaie": "Charlevoix",
++    "les-eboulements": "Charlevoix",
++    "saint-sauveur": "Laurentides",
++    "sainte-adele": "Laurentides",
++    "mont-tremblant": "Laurentides",
++}
++
++_STAT_RE = re.compile(
++    r'<span class="(capacity|bedrooms|beds|restrooms)">'
++    r"(?:(?!</span>).)*?([\d.,]+)\s*</span>", re.S)
++
++_PRIX_RE = re.compile(
++    r"<h3>\s*(\d+)\s*nuits?\s*à partir de[^<]*<br\s*/?>\s*"
++    r"<span>\s*([\d\s,.  ]+)\s*\$\s*</span>", re.S)
++
++
++def _montant(raw: str) -> float | None:
++    try:
++        return float(re.sub(r"[\s  ]", "", raw).replace(",", "."))
++    except ValueError:
++        return None
++
++
++class ChaletsAlpins(StConnector):
++    source_id = "chaletsalpins"
++
++    # -- inventaire (sitemap FR + lastmod) -----------------------------------
++    def _sitemap_urls(self) -> dict[str, tuple[str, str]]:
++        """slug -> (url détail FR, lastmod)."""
++        xml = self.get(SITEMAP).text
++        urls: dict[str, tuple[str, str]] = {}
++        for bloc in re.findall(r"<url>(.*?)</url>", xml, re.S):
++            m = re.search(r"<loc>([^<]+)</loc>", bloc)
++            if not m:
++                continue
++            loc = m.group(1).strip()
++            mu = _URL_DETAIL.match(loc)
++            if not mu or mu.group(1) in ("hebergement",):
++                continue
++            lastmod = re.search(r"<lastmod>([^<]+)</lastmod>", bloc)
++            urls.setdefault(mu.group(1),
++                            (loc, lastmod.group(1) if lastmod else ""))
++        return urls
++
++    # -- page détail ---------------------------------------------------------
++    def _detail(self, url: str) -> dict:
++        # ⚠️ le serveur ajoute parfois APRÈS </html> un second rendu avec des
++        # chalets suggérés (autres compteurs/photos) : on tronque au 1er </html>
++        h = self.get(url).text.split("</html>", 1)[0]
++        d: dict = {}
++
++        # JSON-LD Hotel : nom, description, adresse, animaux, commodités
++        for m in re.finditer(r'<script[^>]*application/ld\+json[^>]*>(.*?)'
++                             r"</script>", h, re.S):
++            try:
++                data = json.loads(m.group(1), strict=False)
++            except ValueError:
++                continue
++            if not (isinstance(data, dict) and data.get("@type") == "Hotel"):
++                continue
++            d["title"] = (data.get("name") or "").strip()
++            d["description"] = re.sub(
++                r"\s+", " ", (data.get("description") or "")).strip()[:5000]
++            addr = data.get("address") or {}
++            d["city"] = (addr.get("addressLocality") or "").strip()
++            if data.get("petsAllowed") is not None:
++                d["pets"] = "oui" if str(data["petsAllowed"]) in (
++                    "True", "true", "1") else "non"
++            amen = []
++            for feat in data.get("amenityFeature") or []:
++                nom = (feat.get("name") or "").strip() \
++                    if isinstance(feat, dict) else ""
++                if nom and nom not in amen:
++                    amen.append(nom)
++            if amen:
++                d["amenities"] = amen
++            break
++
++        # compteurs de l'entête (capacité, chambres, lits, salles de bain) —
++        # 1re occurrence seulement (le chalet courant précède toute suggestion)
++        for cls, val in _STAT_RE.findall(h):
++            n = _montant(val)
++            if n is None:
++                continue
++            d.setdefault({"capacity": "capacity", "bedrooms": "bedrooms",
++                          "beds": "beds", "restrooms": "bathrooms"}[cls], n)
++
++        # encadré latéral : « 2 nuits à partir de (printemps) 1 025.00 $ »
++        # → prix / nuit ; certaines unités affichent « Location mensuelle »
++        # (long terme : pas de prix à la nuit, mention conservée)
++        m = _PRIX_RE.search(h)
++        if m:
++            nuits = int(m.group(1)) or 1
++            montant = _montant(m.group(2))
++            if montant:
++                d["price_night"] = round(montant / nuits, 2)
++                d["price_label"] = re.sub(
++                    r"\s+", " ", _html.unescape(
++                        re.sub(r"<[^>]+>", " ", m.group(0)))).strip()
++        elif re.search(r'sidebar scrollbox">\s*<div class="top">\s*'
++                       r"<h3>\s*Location mensuelle", h):
++            d["location_mensuelle"] = True
++
++        # no CITQ (dans le nom/slug « …(CITQ282170) » ou la description)
++        m = re.search(r"CITQ\)?\s*:?\s*#?\s*(\d{6})",
++                      d.get("title", "") + " " + d.get("description", ""))
++        if m:
++            d["citq"] = m.group(1)
++
++        # photos du carrousel (vignettes et icônes écartées, dédoublonnage
++        # sur le nom de base sans suffixe de taille -WxH)
++        imgs, vus = [], set()
++        for u in re.findall(r'(https://(?:www\.)?chaletsalpins\.ca/'
++                            r'wp-content/uploads/[^"\'\s>]+'
++                            r"\.(?:jpe?g|png|webp))", h):
++            base = re.sub(r"-\d+x\d+(?=\.\w+$)", "", u)
++            if base in vus or "-150x150" in u:
++                continue
++            vus.add(base)
++            imgs.append(u)
++        d["images"] = imgs[:20]
++        return d
++
++    # -- contrat --------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        listings: list[StListing] = []
++        for slug, (url, lastmod) in self._sitemap_urls().items():
++            try:
++                d = self.detail(slug, lastmod or "sans-lastmod",
++                                lambda u=url: self._detail(u))
++            except Exception:      # une fiche cassée ≠ inventaire perdu
++                d = {}
++            if not d.get("title"):
++                continue
++            ville = d.get("city", "")
++            region = _VILLE_REGION.get(
++                strip_accents(ville).lower().replace(" ", "-"), "")
++            details = ({"location_mensuelle": True}
++                       if d.get("location_mensuelle") else {})
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=slug,                 # slug WP, stable
++                url=url,
++                title=d["title"],
++                property_type="Chalet",
++                city=ville,
++                region=region,
++                price_night=d.get("price_night"),
++                price_label=d.get("price_label", ""),
++                capacity=d.get("capacity"),
++                bedrooms=d.get("bedrooms"),
++                beds=d.get("beds"),
++                bathrooms=d.get("bathrooms"),
++                pets=d.get("pets"),
++                citq=d.get("citq", ""),
++                description=d.get("description", ""),
++                amenities=d.get("amenities") or [],
++                details=details,
++                images=d.get("images") or [],
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/chaletsbsl.py : Chalets BSL (chaletsbsl.com) — 4 chalets avec spa
++#   sur un domaine privé de Saint-Simon-de-Rimouski (Bas-Saint-Laurent).
++#
++# Méthode : sitemap.xml (index) → sitemap_sections_*.xml → URLs /chalets/<slug>
++#   + lastmod (clé du cache détail ; les /en/ sont ignorées). Pages statiques
++#   (CMS maison Bootstrap) :
++#     - <h3 class="mt-4 fw-600"> = titre (préfixe « Chalets BSL - » retiré) ;
++#     - <h5 class="prix"> « À partir de 610$ pour 2 nuits » → price_night ;
++#     - <p class="capacite"> « 2 pers. 1 chbre. 1 sdb. » ;
++#     - description = <p> entre la capacité et le bloc country-info ;
++#     - commodités = <h6> des blocs country-name ;
++#     - galerie = var chaletImgs = {"ete": […], …} (JSON par saison) ;
++#     - lat/lng = const myLatLng = { lat: …, lng: … } ; CITQ en pied de fiche.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import json
++import re
++
++from ..schema import StListing
++from .base import StConnector
++
++SITE = "https://chaletsbsl.com"
++SITEMAP = SITE + "/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 ChaletsBsl(StConnector):
++    source_id = "chaletsbsl"
++    request_delay = 1.0
++
++    # -- page détail ----------------------------------------------------------
++    def _detail(self, url: str) -> dict:
++        h = self.get(url).text
++        d: dict = {}
++
++        m = re.search(r'(?s)<h3 class="mt-4 fw-600[^"]*"[^>]*>(.*?)</h3>', h)
++        if m:
++            d["title"] = re.sub(r"^Chalets BSL\s*-\s*", "", _text(m.group(1)))
++
++        # « À partir de 610$ pour 2 nuits » → 305 $/nuit
++        m = re.search(r"À partir de\s*([\d\s]+)\$\s*pour\s*(\d+)\s*nuits", h)
++        if m:
++            total = float(m.group(1).replace(" ", ""))
++            nights = int(m.group(2))
++            if nights and 20 <= total / nights <= 20000:
++                d["price_night"] = round(total / nights)
++                d["price_ref"] = f"{total:g} $ pour {nights} nuits"
++
++        # « 2 pers. 1 chbre. 1 sdb. »
++        m = re.search(r'(?s)<p class="capacite[^"]*"[^>]*>(.*?)</p>', h)
++        if m:
++            frag = _text(m.group(1))
++            for pat, key in ((r"(\d+)\s*pers", "capacity"),
++                             (r"(\d+)\s*chbre", "bedrooms"),
++                             (r"(\d+)\s*sdb", "bathrooms")):
++                mm = re.search(pat, frag)
++                if mm:
++                    d[key] = float(mm.group(1))
++
++        # description : les <p> entre la capacité et le bloc country-info
++        i = h.find('class="capacite')
++        j = h.find("country-info")
++        if 0 < i < j:
++            paras = [_text(p) for p in
++                     re.findall(r"(?s)<p[^>]*>(.*?)</p>", h[i:j])]
++            texte = "\n".join(p for p in paras if len(p) > 40)
++            if texte:
++                d["description"] = texte[:5000]
++
++        # commodités : les <h6> (tous portés par les blocs country-name)
++        amen: list[str] = []
++        for h6 in re.findall(r"(?s)<h6[^>]*>(.*?)</h6>", h):
++            t = _text(h6)
++            if t and t not in amen:
++                amen.append(t)
++        if amen:
++            d["amenities"] = amen
++
++        m = re.search(r"const myLatLng = \{\s*lat:\s*(-?\d+\.\d+),"
++                      r"\s*lng:\s*(-?\d+\.\d+)", h)
++        if m:
++            d["lat"], d["lng"] = float(m.group(1)), float(m.group(2))
++        m = re.search(r"CITQ\D{0,25}(\d{6})", h)
++        if m:
++            d["citq"] = m.group(1)
++
++        # galerie : var chaletImgs = {"ete": […], "hiver": […]}
++        m = re.search(r"var chaletImgs = (\{.*?\});", h, re.S)
++        if m:
++            try:
++                seasons = json.loads(m.group(1))
++                imgs: list[str] = []
++                for key in ("ete", *sorted(k for k in seasons if k != "ete")):
++                    for u in seasons.get(key) or []:
++                        if isinstance(u, str) and u.startswith("https://") \
++                                and u not in imgs and len(imgs) < 20:
++                            imgs.append(u)
++                if imgs:
++                    d["images"] = imgs
++            except ValueError:
++                pass
++        return d
++
++    # -- contrat --------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        index = self.get(SITEMAP).text
++        entries: list[tuple[str, str]] = []
++        for sub in re.findall(r"<loc>([^<]+)</loc>", index):
++            if "sitemap_sections" not in sub:
++                continue
++            xml = self.get(sub).text
++            entries += re.findall(r"(?s)<url>\s*<loc>([^<]+)</loc>"
++                                  r"(?:\s*<lastmod>([^<]*)</lastmod>)?", xml)
++
++        listings: list[StListing] = []
++        vus: set[str] = set()
++        for url, lastmod in entries:
++            m = re.match(r"https://chaletsbsl\.com/chalets/([^/]+)/?$", url)
++            if not m:
++                continue
++            slug = m.group(1)
++            if slug in vus:
++                continue
++            vus.add(slug)
++
++            det = self.detail(slug, lastmod or "v1",
++                              lambda u=url: self._detail(u))
++            title = det.get("title") or ""
++            if not title:
++                continue
++
++            price = det.get("price_night")
++            details = {k: v for k, v in {
++                "price_ref": det.get("price_ref") or "",
++                "domain": "Chalets BSL",
++            }.items() if v}
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=slug,
++                url=url,
++                title=title,
++                property_type="Chalet",
++                city="Saint-Simon-de-Rimouski",
++                region="Bas-Saint-Laurent",
++                price_night=float(price) if price else None,
++                price_label=f"à partir de {price:g} $ / nuit" if price else "",
++                capacity=det.get("capacity"),
++                bedrooms=det.get("bedrooms"),
++                bathrooms=det.get("bathrooms"),
++                citq=det.get("citq") or "",
++                description=det.get("description") or "",
++                amenities=det.get("amenities") or [],
++                details=details,
++                images=det.get("images") or [],
++                lat=det.get("lat"),
++                lng=det.get("lng"),
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/chaletsdanslenord.py : Les Chalets dans le Nord
++# (leschaletsdanslenord.com — Laurentides)
++#
++# Petite agence familiale (Sainte-Lucie-des-Laurentides / lac Sarrazin,
++# ~6 chalets) — vitrine WordPress + moteur de réservation HOSTAWAY
++# (reservation.leschaletsdanslenord.com, compte 96792).
++#
++# Méthode :
++#   1. IDS : la racine du moteur Hostaway (Next.js rendu serveur) référence
++#      tous les chalets via des liens "/listings/<id>" ; la homepage WP donne
++#      en plus prix (« dès N $ / nuit ») et lien de la fiche vitrine (l'id
++#      Hostaway est dans l'URL des photos S3 `96792-<id>-…`).
++#   2. DÉTAIL (cache self.detail) : /listings/<id> du moteur embarque le JSON
++#      complet dans le payload React Flight (`self.__next_f`) : prix de base
++#      par nuit, lat/lng, ville, capacité, chambres, sdb, lits, type, note
++#      (sur 10 → /2 par finalize), nb d'avis, ~50 photos, ~70 commodités et
++#      description (référence Flight « $xx » résolue via les segments T<hex>).
++#   External_id = id de listing Hostaway (stable, dans l'URL du moteur).
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import json
++import re
++
++from ..schema import StListing
++from .base import StConnector
++
++SITE = "https://leschaletsdanslenord.com"
++ENGINE = "https://reservation.leschaletsdanslenord.com"
++
++
++def _num(v) -> float | None:
++    try:
++        return float(v) if v not in (None, "") else None
++    except (TypeError, ValueError):
++        return None
++
++
++def _flight_blob(html: str) -> str:
++    parts = []
++    for c in re.findall(r'self\.__next_f\.push\(\[1,"((?:[^"\\]|\\.)*)"\]\)',
++                        html):
++        try:
++            parts.append(json.loads(f'"{c}"'))
++        except ValueError:
++            continue
++    return "".join(parts)
++
++
++def _flight_text(blob: str, ref: str) -> str:
++    """Résout une référence texte Flight « $xx » (segment `xx:T<len hex>,`,
++    longueur en OCTETS utf-8)."""
++    rid = ref.lstrip("$")
++    m = re.search(rf"(?:^|\n){re.escape(rid)}:T([0-9a-f]+),", blob)
++    if not m:
++        return ""
++    n = int(m.group(1), 16)
++    raw = blob[m.end():].encode("utf-8")[:n]
++    return raw.decode("utf-8", errors="ignore")
++
++
++class ChaletsDansLeNord(StConnector):
++    source_id = "chaletsdanslenord"
++
++    # -- ids + carte prix/urls vitrine --------------------------------------
++    def _engine_ids(self) -> list[str]:
++        h = self.get(f"{ENGINE}/").text
++        return sorted(set(re.findall(r'"/listings/(\d+)"', h)))
++
++    def _wp_cards(self) -> dict[str, dict]:
++        """id Hostaway → {url fiche vitrine, prix « dès N $ »} (homepage WP)."""
++        try:
++            h = self.get(f"{SITE}/").text
++        except Exception:
++            return {}
++        cards: dict[str, dict] = {}
++        for block in re.split(r'<li class="lcdln-hsg__card"', h)[1:]:
++            m = re.search(r"hostaway-platform[^\"]*/listing/96792-(\d+)-",
++                          block)
++            if not m:
++                continue
++            hid = m.group(1)
++            card: dict = {}
++            m = re.search(r'class="lcdln-hsg__card-btn" href="([^"]+)"', block)
++            if m:
++                card["url"] = m.group(1)
++            m = re.search(r"dès\s*([\d ,]+)\s*\$\s*/\s*nuit", block)
++            if m:
++                card["price"] = float(m.group(1).replace(" ", "")
++                                      .replace(",", "."))
++            cards[hid] = card
++        return cards
++
++    def _wp_fiche(self, url: str) -> dict:
++        """Titre + description EN FRANÇAIS depuis la fiche vitrine WP."""
++        h = self.get(url).text
++        d: dict = {}
++        m = re.search(r"(?s)<h1[^>]*>(.*?)</h1>", h)
++        if m:
++            d["title"] = re.sub(r"\s+", " ",
++                                re.sub(r"<[^>]+>", " ", m.group(1))).strip()
++        m = re.search(r"(?s)<main[^>]*>(.*?)</main>", h)
++        if m:
++            import html as _h
++            paras, seen = [], set()
++            for p in re.findall(r"(?s)<p[^>]*>(.*?)</p>", m.group(1)):
++                t = _h.unescape(re.sub(r"\s+", " ",
++                                       re.sub(r"<[^>]+>", " ", p))).strip()
++                if len(t) < 60 or t in seen or "Voir les" in t[:30]:
++                    continue
++                seen.add(t)
++                paras.append(t)
++                if len(paras) >= 10:
++                    break
++            if paras:
++                d["description"] = " ".join(paras)[:4000]
++        return d
++
++    # -- détail (moteur Hostaway + fiche vitrine FR) --------------------------
++    def _detail(self, hid: str, wp_url: str = "") -> dict:
++        h = self.get(f"{ENGINE}/listings/{hid}").text
++        blob = _flight_blob(h)
++        i = blob.find(f'"listing":{{"id":{hid}')
++        if i < 0:
++            return {}
++        obj, _ = json.JSONDecoder().raw_decode(blob[i + len('"listing":'):])
++        inner = obj.get("listing") or {}
++
++        desc = str(inner.get("description") or "")
++        if desc.startswith("$"):
++            desc = _flight_text(blob, desc)
++        desc = re.sub(r"\s+", " ", desc).strip()
++
++        images = []
++        for ph in obj.get("listingImage") or []:
++            u = (ph or {}).get("url")
++            if u and u not in images:
++                images.append(u)
++            if len(images) >= 20:
++                break
++
++        # fiche vitrine WP : titre + description en français (prioritaires)
++        wp: dict = {}
++        if wp_url:
++            try:
++                wp = self._wp_fiche(wp_url)
++            except Exception:
++                wp = {}
++        if wp.get("description"):
++            desc = wp["description"]
++
++        pt = ((inner.get("propertyType") or {}).get("name") or "").strip()
++        return {
++            "title": wp.get("title") or (inner.get("name") or "").strip(),
++            "price": _num(inner.get("price")),
++            "lat": _num(inner.get("lat")),
++            "lng": _num(inner.get("lng")),
++            "city": (inner.get("city") or "").strip(),
++            "capacity": _num(inner.get("personCapacity")),
++            "bedrooms": _num(inner.get("bedroomsNumber")),
++            "beds": _num(inner.get("bedsNumber")),
++            "bathrooms": _num(inner.get("bathroomsNumber")),
++            "property_type": pt,
++            "rating": _num(obj.get("averageReviewRating")),
++            "reviews": obj.get("reviewsCount"),
++            "description": desc[:4000],
++            "amenities": [n for n in
++                          (((a.get("amenity") or {}).get("name")
++                            or a.get("name") or "").strip()
++                           for a in obj.get("listingAmenity") or []
++                           if isinstance(a, dict)) if n][:80],
++            "images": images,
++        }
++
++    # -- contrat ----------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        cards = self._wp_cards()
++        listings: list[StListing] = []
++        for hid in self._engine_ids():
++            card = cards.get(hid) or {}
++            key = json.dumps([hid, card.get("price"), card.get("url")])
++            try:
++                det = self.detail(
++                    hid, key,
++                    lambda i=hid, u=card.get("url") or "": self._detail(i, u))
++            except Exception:
++                det = {}
++            if not det.get("title"):
++                continue
++
++            price = det.get("price") or card.get("price")
++            reviews = det.get("reviews")
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=hid,
++                url=card.get("url") or f"{ENGINE}/listings/{hid}",
++                title=det["title"],
++                property_type=det.get("property_type") or "Chalet",
++                city=det.get("city") or "",
++                region="Laurentides",
++                price_night=price,
++                price_label=(f"à partir de {price:.0f} $ / nuit"
++                             if price else ""),
++                capacity=det.get("capacity"),
++                bedrooms=det.get("bedrooms"),
++                beds=det.get("beds"),
++                bathrooms=det.get("bathrooms"),
++                rating=det.get("rating"),
++                reviews=int(reviews) if reviews else None,
++                description=det.get("description") or "",
++                amenities=det.get("amenities") or [],
++                details={"booking_url": f"{ENGINE}/listings/{hid}"},
++                images=det.get("images") or [],
++                lat=det.get("lat"),
++                lng=det.get("lng"),
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/domesstcome.py : Dômes St-Côme (domesstcome.com) — 4 dômes
++#   géodésiques avec spa privé et vue panoramique à Saint-Côme (Lanaudière).
++#
++# Méthode : sitemap Wix (index) → dynamic-domes_*-sitemap.xml → 4 URLs
++#   /domes/<slug> + lastmod (clé du cache détail). Pages Wix statiques :
++#     - <h1> = nom du dôme ; sous-titre « Vue panoramique | Spa privé » ;
++#     - « À partir de 370$/nuit » → price_night ;
++#     - sections LITS / AUTRES / CUISINE / À L'EXTÉRIEUR / SALLE DE BAIN
++#       (texte riche Wix) → amenities ; beds = nb de « Lit … » sous LITS ;
++#     - CITQ (6 chiffres) dans le pied de page ;
++#     - images : médias wixstatic ~mv2 servis en grand (w ≥ 900) — la galerie
++#       Pro Gallery est chargée en JS, seuls les héros sont statiques.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import re
++
++from ..schema import StListing
++from .base import StConnector
++
++SITE = "https://www.domesstcome.com"
++SITEMAP = SITE + "/sitemap.xml"
++
++_SECTIONS = ("LITS", "AUTRES", "CUISINE", "À L'EXTÉRIEUR", "SALLE DE BAIN")
++
++_TAG_RE = re.compile(r"<[^>]+>")
++
++
++def _lines(fragment: str) -> list[str]:
++    """HTML riche Wix → lignes de texte propres (CSS inline filtré)."""
++    txt = re.sub(r"\|(?:\s*\|)+", "\n",
++                 re.sub(r"\s+", " ", _TAG_RE.sub("|", fragment)))
++    out = []
++    for x in txt.split("\n"):
++        x = _html.unescape(x).strip(" |").strip()
++        x = re.sub(r"\s*\|\s*", " | ", x)
++        if x and len(x) > 2 and "{" not in x and "--" not in x:
++            out.append(x)
++    return out
++
++
++class DomesStCome(StConnector):
++    source_id = "domesstcome"
++    request_delay = 1.0
++
++    # -- page détail ----------------------------------------------------------
++    def _detail(self, url: str) -> dict:
++        h = self.get(url).text
++        d: dict = {}
++
++        m = re.search(r"(?s)<h1[^>]*>(.*?)</h1>", h)
++        if m:
++            d["title"] = _html.unescape(
++                re.sub(r"\s+", " ", _TAG_RE.sub(" ", m.group(1)))).strip()
++
++        m = re.search(r"À partir de\s*(\d+)\s*\$\s*/\s*nuit", h)
++        if m:
++            d["price_night"] = float(m.group(1))
++
++        m = re.search(r"CITQ\D{0,25}(\d{6})", h)
++        if m:
++            d["citq"] = m.group(1)
++
++        # sous-titre (« Vue panoramique | Spa privé ») → description
++        i, j = h.find("<h1"), h.find("LITS")
++        if 0 <= i < j:
++            head = [x for x in _lines(h[i:j])
++                    if x != d.get("title") and "À partir de" not in x
++                    and "Détails" not in x]
++            if head:
++                d["description"] = head[0][:500]
++
++        # sections LITS…SALLE DE BAIN → amenities (entêtes exclues)
++        i = h.find("LITS")
++        j = h.find("Réserver", max(i, 0))
++        beds = 0
++        amen: list[str] = []
++        if 0 <= i < j:
++            unescaped_secs = {s for s in _SECTIONS}
++            current = ""
++            for x in _lines(h[i:j]):
++                if x.upper() in unescaped_secs:
++                    current = x.upper()
++                    continue
++                if x in amen or len(x) > 80:
++                    continue
++                amen.append(x)
++                if current == "LITS" and re.match(r"Lit\b", x, re.I):
++                    beds += 1
++        if amen:
++            d["amenities"] = amen
++        if beds:
++            d["beds"] = float(beds)
++
++        # images : médias wixstatic servis en grand (héros)
++        big: dict[str, int] = {}
++        for mid, w in re.findall(r"static\.wixstatic\.com/media/"
++                                 r"([\w~%.]+)/v1/fill/w_(\d+)", h):
++            w = int(w)
++            if w >= 900:
++                big[mid] = max(big.get(mid, 0), w)
++        imgs = [f"https://static.wixstatic.com/media/{mid}"
++                for mid in big][:15]
++        if imgs:
++            d["images"] = imgs
++        return d
++
++    # -- contrat --------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        index = self.get(SITEMAP).text
++        entries: list[tuple[str, str]] = []
++        for sub in re.findall(r"<loc>([^<]+)</loc>", index):
++            if "dynamic-domes" not in sub:
++                continue
++            xml = self.get(sub).text
++            entries += re.findall(r"(?s)<url>\s*<loc>([^<]+)</loc>"
++                                  r"(?:\s*<lastmod>([^<]*)</lastmod>)?", xml)
++
++        listings: list[StListing] = []
++        vus: set[str] = set()
++        for url, lastmod in entries:
++            m = re.match(r"https://www\.domesstcome\.com/domes/([^/]+)/?$", url)
++            if not m:
++                continue
++            slug = m.group(1)
++            if slug in vus:
++                continue
++            vus.add(slug)
++
++            det = self.detail(slug, lastmod or "v1",
++                              lambda u=url: self._detail(u))
++            title = det.get("title") or ""
++            if not title:
++                continue
++
++            price = det.get("price_night")
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=slug,
++                url=url,
++                title=title,
++                property_type="Dôme",
++                city="Saint-Côme",
++                region="Lanaudière",
++                price_night=price,
++                price_label=f"À partir de {price:g} $ / nuit" if price else "",
++                beds=det.get("beds"),
++                citq=det.get("citq") or "",
++                description=det.get("description") or "",
++                amenities=det.get("amenities") or [],
++                details={"domain": "Dômes St-Côme"},
++                images=det.get("images") or [],
++            ))
++        return listings

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

				`@@ -21,7 +21,13 @@`
21	# L'inventaire recoupe en partie Vrbo (même groupe) mais avec ses propres ids	21	# L'inventaire recoupe en partie Vrbo (même groupe) mais avec ses propres ids
22	# et des exclusivités hôtelières-résidentielles (apparts-hôtels, glamping).	22	# et des exclusivités hôtelières-résidentielles (apparts-hôtels, glamping).
23	#	23	#
24	−# Réglage env : LOUKA_EXPEDIA_LIMIT (nb max d'annonces, pour tester petit).	24	+# Enrichissement : la page détail hXXXXXX.Hotel-Information (Scrapfly ASP
		25	+# SANS rendu JS — le SSR suffit) porte description, commodités, lat/lng et
		26	+# ~6 photos (parseur partagé avec Vrbo : _expediadetail.py).
		27	+#
		28	+# Réglages env : LOUKA_EXPEDIA_LIMIT (nb max d'annonces, pour tester petit),
		29	+# LOUKA_EXPEDIA_DETAIL_LIMIT (fetchs détail par sync, défaut
		30	+# 100 ; cache permanent, le parc se complète au fil des syncs).
25	# -----------------------------------------------------------------------------	31	# -----------------------------------------------------------------------------
26	from __future__ import annotations	32	from __future__ import annotations
27		33
				`@@ -33,8 +39,13 @@ from urllib.parse import quote`
33	from bs4 import BeautifulSoup	39	from bs4 import BeautifulSoup
34		40
35	from ..schema import StListing	41	from ..schema import StListing
		42	+from . import _expediadetail as _ed
36	from .base import StConnector	43	from .base import StConnector
37		44
		45	+
		46	+class _DetailSkip(Exception):
		47	+ """Fiche détail sautée (budget épuisé / page invalide) — pas de cache."""
		48	+
38	# (destination Expedia, ville affichée par défaut, région touristique QC)	49	# (destination Expedia, ville affichée par défaut, région touristique QC)
39	DESTINATIONS = [	50	DESTINATIONS = [
40	("Mont-Tremblant, Quebec, Canada", "Mont-Tremblant", "Laurentides"),	51	("Mont-Tremblant, Quebec, Canada", "Mont-Tremblant", "Laurentides"),
				`@@ -203,6 +214,39 @@ class Expedia(StConnector):`
203	images=images,	214	images=images,
204	)	215	)
205		216
		217	+ # -- enrichissement par la page détail ---------------------------------------
		218	+ def _enrich_details(self, listings: list[StListing]) -> None:
		219	+ """Visite les fiches détail via le cache self.detail() sous budget :
		220	+ les hits de cache sont gratuits, seuls les fetchs réseau comptent."""
		221	+ limit = max(0, int(os.environ.get("LOUKA_EXPEDIA_DETAIL_LIMIT", "100")
		222	+ or 100))
		223	+ used = enriched = streak = 0
		224	+ for lst in listings:
		225	+ def fetch_fn(url=lst.url):
		226	+ nonlocal used, streak
		227	+ if used >= limit or streak >= 5: # tempête anti-bot : on coupe
		228	+ raise _DetailSkip
		229	+ used += 1
		230	+ html = self.get_scrapfly(url, render_js=False, asp=True)
		231	+ payload = _ed.parse_detail(html)
		232	+ if not payload:
		233	+ streak += 1
		234	+ raise _DetailSkip # blocage/vide : pas de cache
		235	+ streak = 0
		236	+ return payload
		237	+
		238	+ try:
		239	+ d = self.detail(lst.external_id, "v1", fetch_fn)
		240	+ except _DetailSkip:
		241	+ continue
		242	+ except Exception: # noqa: BLE001 — une fiche ne bloque pas le run
		243	+ continue
		244	+ if d:
		245	+ _ed.apply_detail(lst, d)
		246	+ enriched += 1
		247	+ print(f"[expedia] détail : {enriched} annonces enrichies"
		248	+ f" ({used}/{limit} fetchs réseau)", file=sys.stderr)
		249	+
206	# -- contrat -----------------------------------------------------------------	250	# -- contrat -----------------------------------------------------------------
207	def fetch(self) -> list[StListing]:	251	def fetch(self) -> list[StListing]:
208	limit = int(os.environ.get("LOUKA_EXPEDIA_LIMIT", "0") or 0)	252	limit = int(os.environ.get("LOUKA_EXPEDIA_LIMIT", "0") or 0)
				`@@ -216,7 +260,9 @@ class Expedia(StConnector):`
216	for dest, city, region in DESTINATIONS:	260	for dest, city, region in DESTINATIONS:
217	for sort in SORTS:	261	for sort in SORTS:
218	if limit and len(listings) >= limit:	262	if limit and len(listings) >= limit:
219	− return list(listings.values())	263	+ out = list(listings.values())
		264	+ self._enrich_details(out)
		265	+ return out
220	url = ("https://www.expedia.ca/Hotel-Search?destination="	266	url = ("https://www.expedia.ca/Hotel-Search?destination="
221	+ quote(dest)	267	+ quote(dest)
222	+ "&adults=2&categorySearch=vacation_rentals_option")	268	+ "&adults=2&categorySearch=vacation_rentals_option")
				`@@ -250,4 +296,6 @@ class Expedia(StConnector):`
250	print(f"[expedia] {city} ({sort}) :"	296	print(f"[expedia] {city} ({sort}) :"
251	f" {len(listings) - n_before} nouvelles"	297	f" {len(listings) - n_before} nouvelles"
252	f" (total {len(listings)})", file=sys.stderr)	298	f" (total {len(listings)})", file=sys.stderr)
253	− return list(listings.values())	299	+ out = list(listings.values())
		300	+ self._enrich_details(out)
		301	+ return out

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/gitesauquebec.py : GitesAuQuebec.com — annuaire indépendant de
++# gîtes et auberges (B&B). Annuaire en fin de vie : l'inventaire ACTIF est
++# aujourd'hui minuscule (~7 fiches, « Page 1 de 1 » sur la recherche sans
++# critère), mais les fiches restantes sont riches et le connecteur suivra
++# l'inventaire s'il remonte.
++#
++# Méthode (ASP.NET WebForms, aucun anti-bot) :
++#   1. LISTE : GET /Resultats.aspx sans critère → toutes les annonces actives
++#      (cartes en tables imbriquées : lien /<id>, tarif « 145$ - 205$ nuit »).
++#      La pagination (« Page 1 de N ») est un postback __VIEWSTATE : tant que
++#      N = 1 on n'en a pas besoin ; si N > 1 un avertissement est émis (le
++#      rejouer n'a rien à répliquer aujourd'hui, l'annuaire tient sur 1 page).
++#   2. FICHE /<id> (cache self.detail, clé mensuelle) : contrôles ASP.NET
++#      stables — titre « PL-<id> : Nom », CPH_litInfoGen (type, capacité,
++#      chambres, salles de bain, lits, animaux, fumeurs), localisation
++#      (région / ville), CPH_lblDesc, CPH_lblNoEtablissementValeur (CITQ),
++#      CPH_hidAdrMap (« lat, lng »), CPH_pnlTarif, équipements (img alt),
++#      photos /_photos/grand/.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import re
++import sys
++import time
++
++from ..schema import StListing, normalize_region
++from .base import StConnector
++
++BASE = "https://www.gitesauquebec.com"
++RESULTATS = f"{BASE}/Resultats.aspx"
++
++_ID_RE = re.compile(r"href='/(\d+)'")
++_PAGE_RE = re.compile(r"Page\s+(\d+)\s+de\s+(\d+)")
++_TARIF_RE = re.compile(r"(\d[\d\s,.]*\$[^<]{0,40})")
++_COORD_RE = re.compile(
++    r'id="CPH_hidAdrMap" value="(-?\d+\.\d+),\s*(-?\d+\.\d+)"')
++_NUM_RE = re.compile(r"(\d+)")
++
++# « Type hébergement » de l'annuaire → type canonique Lou-Ka
++_TYPES = {"gîte": "Gîte", "gite": "Gîte", "auberge": "Auberge",
++          "b&b": "Gîte", "couette et café": "Gîte"}
++
++# l'annuaire écrit « Cantons de l'est / Estrie », « Centre du Québec »…
++_REGIONS = {"cantons de l'est / estrie": "Cantons-de-l'Est",
++            "centre du québec": "Centre-du-Québec"}
++
++
++class GitesAuQuebec(StConnector):
++    source_id = "gitesauquebec"
++    request_delay = 1.0
++
++    # -- liste ------------------------------------------------------------------
++    def _liste(self) -> dict[str, str]:
++        """Annonces actives → {id: libellé de tarif de la carte}."""
++        html = self.get(RESULTATS).text
++        m = _PAGE_RE.search(re.sub(r"<[^>]+>", " ", html))
++        if m and int(m.group(2)) > 1:
++            print(f"[gitesauquebec] pagination inattendue ({m.group(0)}) : "
++                  "seule la page 1 est lue (postback __VIEWSTATE à rejouer)",
++                  file=sys.stderr)
++        tarifs: dict[str, str] = {}
++        # une carte = tout le HTML entre deux liens de fiche successifs
++        morceaux = _ID_RE.split(html)
++        for i in range(1, len(morceaux), 2):
++            gid, bloc = morceaux[i], morceaux[i + 1]
++            if gid in tarifs and tarifs[gid]:
++                continue
++            tarif = ""
++            j = bloc.find("TARIFICATION")
++            if j >= 0:
++                mm = _TARIF_RE.search(re.sub(r"<[^>]+>", " ", bloc[j:j + 800]))
++                if mm:
++                    tarif = re.sub(r"\s+", " ", mm.group(1)).strip()
++            tarifs[gid] = tarif
++        return tarifs
++
++    # -- fiche ------------------------------------------------------------------
++    def _fetch_fiche(self, gid: str) -> dict:
++        from bs4 import BeautifulSoup
++        html = self.get(f"{BASE}/{gid}").text
++        soup = BeautifulSoup(html, "html.parser")
++        d: dict = {}
++
++        # en-tête « PL-3778 : Gite du Village » (préfixe variable : PL, DI…)
++        h1 = soup.find(string=re.compile(rf"[A-Z]{{1,3}}-{gid}\s*:"))
++        if h1:
++            d["nom"] = h1.split(":", 1)[1].strip()
++            m = re.match(rf"([A-Z]{{1,3}}-{gid})", h1.strip())
++            if m:
++                d["no_annonce"] = m.group(1)
++        if not d.get("nom"):
++            # repli : <title> = « Gîte <ville>, <région>, <nom…>, XX-<id> »
++            title = soup.title.get_text(strip=True) if soup.title else ""
++            m = re.match(rf"[^,]+,[^,]+,\s*(.+?),?\s*([A-Z]{{1,3}}-{gid})$",
++                         title)
++            if m:
++                d["nom"], d["no_annonce"] = m.group(1).strip(), m.group(2)
++        if not d.get("nom"):
++            return {}
++
++        # Informations générales : « Étiquette :&nbsp;Valeur » dans CPH_litInfoGen
++        infos: dict[str, str] = {}
++        bloc = soup.find(id="CPH_litInfoGen")
++        if bloc is not None:
++            for cell in bloc.get_text("\n").split("\n"):
++                label, sep, val = cell.partition(":")
++                if sep and val.strip():
++                    infos[label.strip().lower()] = val.strip()
++        d["type"] = infos.get("type hébergement", "")
++        m = _NUM_RE.search(infos.get("capacité d'accueil", ""))
++        if m:
++            d["capacity"] = int(m.group(1))
++        m = _NUM_RE.search(infos.get("chambres", ""))
++        if m:
++            d["bedrooms"] = int(m.group(1))
++        m = _NUM_RE.search(infos.get("salles de bain", ""))
++        if m:
++            d["bathrooms"] = int(m.group(1))
++        d["lits"] = infos.get("lits", "")
++        animaux = infos.get("animaux permis", "").lower()
++        if animaux.startswith("oui"):
++            d["pets"] = "oui"
++        elif animaux.startswith("non"):
++            d["pets"] = "non"
++
++        # Localisation : lignes « Région : / Ville : » du tableau
++        texte = soup.get_text("\n")
++        for champ, cle in (("Région", "region"), ("Ville", "ville")):
++            m = re.search(rf"{champ}\s*:\s*\n+\s*([^\n]+)", texte)
++            if m:
++                d[cle] = m.group(1).strip()
++
++        desc = soup.find(id="CPH_lblDesc")
++        if desc is not None:
++            d["description"] = desc.get_text("\n", strip=True)[:2500]
++
++        citq = soup.find(id="CPH_lblNoEtablissementValeur")
++        if citq is not None:
++            d["citq"] = citq.get_text(strip=True)
++
++        m = _COORD_RE.search(html)
++        if m:
++            d["lat"], d["lng"] = float(m.group(1)), float(m.group(2))
++
++        tarif = soup.find(id="CPH_pnlTarif")
++        if tarif is not None:
++            d["tarif"] = re.sub(
++                r"\s+", " ",
++                tarif.get_text(" ", strip=True).removeprefix("Tarification")
++            ).strip()[:300]
++
++        # équipements & activités : alt des pictogrammes
++        amen: list[str] = []
++        for img in soup.find_all("img", src=re.compile("equipement")):
++            alt = (img.get("alt") or "").strip()
++            if alt and alt not in amen:
++                amen.append(alt)
++        d["amenities"] = amen[:40]
++
++        imgs: list[str] = []
++        for img in soup.find_all("img", src=re.compile(r"/_photos/")):
++            u = img.get("src") or ""
++            u = re.sub(r"/_photos/(thumb/)?", "/_photos/grand/", u)
++            if not u.startswith("http"):
++                u = BASE + u
++            if u not in imgs:
++                imgs.append(u)
++        d["images"] = imgs[:12]
++        return d
++
++    # -- contrat ----------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        month = time.strftime("%Y-%m")      # re-visite mensuelle (tarifs)
++        listings: list[StListing] = []
++        for gid, tarif_carte in sorted(self._liste().items(),
++                                       key=lambda kv: int(kv[0])):
++            try:
++                d = self.detail(gid, month,
++                                lambda g=gid: self._fetch_fiche(g))
++            except Exception as exc:  # noqa: BLE001
++                print(f"[gitesauquebec] fiche {gid} : {exc}", file=sys.stderr)
++                continue
++            if not d.get("nom"):
++                continue
++
++            price_label = d.get("tarif") or tarif_carte
++            region = d.get("region", "")
++            region = _REGIONS.get(region.lower(), normalize_region(region))
++            details = {k: v for k, v in {
++                "no_annonce": d.get("no_annonce", f"PL-{gid}"),
++                "lits": d.get("lits", ""),
++            }.items() if v}
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=gid,
++                url=f"{BASE}/{gid}",
++                title=d["nom"],
++                property_type=_TYPES.get(d.get("type", "").lower(), "Gîte"),
++                city=d.get("ville", ""),
++                region=region,
++                price_label=price_label,
++                capacity=float(d["capacity"]) if d.get("capacity") else None,
++                bedrooms=float(d["bedrooms"]) if d.get("bedrooms") else None,
++                bathrooms=(float(d["bathrooms"])
++                           if d.get("bathrooms") else None),
++                pets=d.get("pets"),
++                citq=d.get("citq", ""),
++                description=d.get("description", ""),
++                amenities=d.get("amenities") or [],
++                details=details,
++                images=d.get("images") or [],
++                lat=d.get("lat"),
++                lng=d.get("lng"),
++            ))
++        return listings

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

				`@@ -17,7 +17,10 @@`
17	# /fr/repertoire/detailorganization/id/<id> — HTML serveur : nom (h1),	17	# /fr/repertoire/detailorganization/id/<id> — HTML serveur : nom (h1),
18	# description, « Types d'hébergement » (Gîte/Auberge du Passant, Maison	18	# description, « Types d'hébergement » (Gîte/Auberge du Passant, Maison
19	# de Campagne…), numéro CITQ (#attestation), classification (soleils),	19	# de Campagne…), numéro CITQ (#attestation), classification (soleils),
20	−# adresse postale (spans), téléphone, site web, photos du carrousel.	20	+# adresse postale (spans), téléphone, site web, photos du carrousel,
		21	+# coordonnées lat/lng extraites de l'iframe Google Maps (paramètres
		22	+# !2d<lng>!3d<lat> de l'embed — présent sur toutes les fiches),
		23	+# chambres/capacité glanées dans la description quand mentionnées.
21	# Pas de prix affiché (les tarifs sont chez chaque établissement).	24	# Pas de prix affiché (les tarifs sont chez chaque établissement).
22	# -----------------------------------------------------------------------------	25	# -----------------------------------------------------------------------------
23	from __future__ import annotations	26	from __future__ import annotations
				`@@ -69,6 +72,11 @@ _TYPES = [`
69	]	72	]
70		73
71	_TAG_RE = re.compile(r"<[^>]+>")	74	_TAG_RE = re.compile(r"<[^>]+>")
		75	+# iframe Google Maps : …/maps/embed?pb=…!2d<longitude>!3d<latitude>!…
		76	+_GMAP_RE = re.compile(r"google\.com/maps/embed\?pb=[^\"']*"
		77	+ r"!2d(-?\d+\.\d+)!3d(-?\d+\.\d+)")
		78	+_CAP_RE = re.compile(r"(\d{1,2})\s*personnes")
		79	+_CHAMBRES_RE = re.compile(r"(\d{1,2})\s*chambres")
72		80
73		81
74	def _text(fragment: str) -> str:	82	def _text(fragment: str) -> str:
				`@@ -149,6 +157,12 @@ class GitesPassant(StConnector):`
149	if m:	157	if m:
150	d["website"] = m.group(1)	158	d["website"] = m.group(1)
151		159
		160	+ # géolocalisation : centre de l'iframe Google Maps (brut : l'iframe
		161	+ # est parfois injectée par un <script> retiré de `h`)
		162	+ m = _GMAP_RE.search(brut)
		163	+ if m:
		164	+ d["lng"], d["lat"] = float(m.group(1)), float(m.group(2))
		165	+
152	# photos : le carrousel de la fiche seulement (ailleurs sur la page,	166	# photos : le carrousel de la fiche seulement (ailleurs sur la page,
153	# les « Suggestions d'articles » ont aussi des images membres)	167	# les « Suggestions d'articles » ont aussi des images membres)
154	logo = ""	168	logo = ""
				`@@ -183,8 +197,9 @@ class GitesPassant(StConnector):`
183		197
184	listings: list[StListing] = []	198	listings: list[StListing] = []
185	for mid in ids:	199	for mid in ids:
186	− # fiche rafraîchie une fois par mois (pas de lastmod côté liste)	200	+ # fiche rafraîchie une fois par mois (pas de lastmod côté liste) ;
187	− det = self.detail(mid, time.strftime("%Y-%m"),	201	+ # v2 : parseur géo (iframe Google Maps) ajouté 2026-08-25
		202	+ det = self.detail(mid, time.strftime("%Y-%m") + "-v2",
188	lambda i=mid: self._fiche(i))	203	lambda i=mid: self._fiche(i))
189	if not det.get("title"):	204	if not det.get("title"):
190	continue	205	continue
				`@@ -203,6 +218,12 @@ class GitesPassant(StConnector):`
203	"(Terroir et Saveurs du Québec)",	218	"(Terroir et Saveurs du Québec)",
204	}.items() if v}	219	}.items() if v}
205		220
		221	+ # capacité / chambres : mentions dans la description (rare)
		222	+ desc = det.get("description") or ""
		223	+ caps = [int(x) for x in _CAP_RE.findall(desc) if 1 <= int(x) <= 40]
		224	+ rooms = [int(x) for x in _CHAMBRES_RE.findall(desc)
		225	+ if 1 <= int(x) <= 30]
		226	+
206	street = det.get("street") or ""	227	street = det.get("street") or ""
207	city = det.get("city") or ""	228	city = det.get("city") or ""
208	listings.append(StListing(	229	listings.append(StListing(
				`@@ -214,10 +235,14 @@ class GitesPassant(StConnector):`
214	address=", ".join(p for p in (street, city) if p),	235	address=", ".join(p for p in (street, city) if p),
215	city=city,	236	city=city,
216	region=regions.get(mid, ""),	237	region=regions.get(mid, ""),
		238	+ capacity=float(max(caps)) if caps else None,
		239	+ bedrooms=float(max(rooms)) if rooms else None,
217	citq=det.get("citq") or "",	240	citq=det.get("citq") or "",
218	− description=det.get("description") or "",	241	+ description=desc,
219	details=details,	242	details=details,
220	images=det.get("images") or [],	243	images=det.get("images") or [],
		244	+ lat=det.get("lat"),
		245	+ lng=det.get("lng"),
221	))	246	))
222	if limit and len(listings) >= limit:	247	if limit and len(listings) >= limit:
223	break	248	break

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

				`@@ -11,20 +11,36 @@`
11	# catégorie, ville + coordonnées, prix (estimated_rate.daily_rate en devise	11	# catégorie, ville + coordonnées, prix (estimated_rate.daily_rate en devise
12	# originale, CAD au Québec), chambres/lits, capacité par unité	12	# originale, CAD au Québec), chambres/lits, capacité par unité
13	# (units_distribution), note sur 5, commodités (nested_features), photos.	13	# (units_distribution), note sur 5, commodités (nested_features), photos.
14	−# Une seule requête paginée suffit — pas de page détail nécessaire.	14	+# Une seule requête paginée suffit pour la liste ; seule la DESCRIPTION
		15	+# n'y figure pas → elle est prise sur la page détail (aucun anti-bot non
		16	+# plus), dans le bloc SSR <noscript id="description-content">, avec repli
		17	+# sur la <meta name="description">. Cache permanent dans louka_ct.db.
15	#	18	#
16	# URL publique : https://glampinghub.com<absolute_url_en>. Région touristique	19	# URL publique : https://glampinghub.com<absolute_url_en>. Région touristique
17	# déduite des coordonnées (centroïdes partagés avec airbnb.py).	20	# déduite des coordonnées (centroïdes partagés avec airbnb.py).
18	−# Réglage env : LOUKA_GLAMPINGHUB_LIMIT (nb max de fiches, 0 = tout).	21	+# Réglages env : LOUKA_GLAMPINGHUB_LIMIT (nb max de fiches, 0 = tout),
		22	+# LOUKA_GLAMPINGHUB_DETAIL_LIMIT (fetchs détail/sync, défaut 250).
19	# -----------------------------------------------------------------------------	23	# -----------------------------------------------------------------------------
20	from __future__ import annotations	24	from __future__ import annotations
21		25
		26	+import html as _html
22	import os	27	import os
		28	+import re
		29	+import sys
23		30
24	from ..schema import StListing	31	from ..schema import StListing
25	from .base import StConnector	32	from .base import StConnector
26	from .airbnb import _region_from_latlng	33	from .airbnb import _region_from_latlng
27		34
		35	+
		36	+class _DetailSkip(Exception):
		37	+ """Fiche détail sautée (budget épuisé) — pas de mise en cache."""
		38	+
		39	+
		40	+_DESC_RE = re.compile(r'<noscript id="description-content">(.*?)</noscript>',
		41	+ re.S)
		42	+_META_RE = re.compile(r'<meta name="description" content="([^"]+)"')
		43	+
28	SITE = "https://glampinghub.com"	44	SITE = "https://glampinghub.com"
29	API = f"{SITE}/search-accommodations/"	45	API = f"{SITE}/search-accommodations/"
30	PAGE_SIZE = 24	46	PAGE_SIZE = 24
				`@@ -87,6 +103,58 @@ class GlampingHub(StConnector):`
87	page += 1	103	page += 1
88	return items	104	return items
89		105
		106	+ # -- description (page détail, SSR ouvert) --------------------------------
		107	+ @staticmethod
		108	+ def _parse_description(html: str) -> dict:
		109	+ """{description} depuis le bloc <noscript> SSR (repli : meta)."""
		110	+ desc = ""
		111	+ m = _DESC_RE.search(html or "")
		112	+ if m:
		113	+ txt = re.sub(r"<br\s*/?>\|</p>\|</h2>", "\n", m.group(1))
		114	+ txt = _html.unescape(re.sub(r"<[^>]+>", " ", txt))
		115	+ lines = [re.sub(r"\s+", " ", ln).strip() for ln in txt.split("\n")]
		116	+ # écarter le bruit : lignes « … », slogan SEO de bas de bloc et
		117	+ # liste de commodités hors-plateforme (pas une description)
		118	+ lines = [ln for ln in lines if ln and ln not in ("...", "…")
		119	+ and not re.match(r"^Book your dream .*!$", ln)
		120	+ and not ln.startswith("Amenities not shown on")]
		121	+ desc = "\n".join(lines).strip()
		122	+ if len(desc) < 40: # fiche laconique (« … ») : repli meta
		123	+ mm = _META_RE.search(html or "")
		124	+ meta = _html.unescape(mm.group(1)).strip() if mm else ""
		125	+ if len(meta) > len(desc):
		126	+ desc = meta
		127	+ return {"description": desc[:6000]} if desc else {}
		128	+
		129	+ def _enrich_details(self, listings: list[StListing]) -> None:
		130	+ """Complète la description via la page détail, sous budget (les hits
		131	+ de cache sont gratuits, seuls les fetchs réseau comptent)."""
		132	+ limit = max(0, int(os.environ.get("LOUKA_GLAMPINGHUB_DETAIL_LIMIT",
		133	+ "250") or 250))
		134	+ used = enriched = 0
		135	+ for lst in listings:
		136	+ if not lst.url.startswith(SITE + "/"):
		137	+ continue
		138	+ def fetch_fn(url=lst.url):
		139	+ nonlocal used
		140	+ if used >= limit:
		141	+ raise _DetailSkip
		142	+ used += 1
		143	+ return self._parse_description(self.get(url).text)
		144	+
		145	+ try:
		146	+ d = self.detail(lst.external_id, "v1", fetch_fn)
		147	+ except _DetailSkip:
		148	+ continue
		149	+ except Exception: # noqa: BLE001 — une fiche ne bloque pas le run
		150	+ continue
		151	+ if d.get("description") and len(d["description"]) > \
		152	+ len(lst.description or ""):
		153	+ lst.description = d["description"]
		154	+ enriched += 1
		155	+ print(f"[glampinghub] détail : {enriched} descriptions"
		156	+ f" ({used}/{limit} fetchs réseau)", file=sys.stderr)
		157	+
90	# -- contrat --------------------------------------------------------------	158	# -- contrat --------------------------------------------------------------
91	def fetch(self) -> list[StListing]:	159	def fetch(self) -> list[StListing]:
92	limit = int(os.environ.get("LOUKA_GLAMPINGHUB_LIMIT", "0") or 0)	160	limit = int(os.environ.get("LOUKA_GLAMPINGHUB_LIMIT", "0") or 0)
				`@@ -174,4 +242,5 @@ class GlampingHub(StConnector):`
174	))	242	))
175	if limit and len(listings) >= limit:	243	if limit and len(listings) >= limit:
176	break	244	break
		245	+ self._enrich_details(listings)
177	return listings	246	return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/hebergementcharlevoix.py : Hébergement Charlevoix
++#   (hebergement-charlevoix.com) — agence de Charlevoix, ~330 chalets.
++#
++# Méthode : site PHP maison, HTML 100 % serveur. Sitemap /sitemap.xml
++#   (301 vers le domaine sans www) → URLs détail
++#   /fr/chalet-a-louer/<ville>/voir/<CODE> (code alphanum stable, ex. ADE-440 ;
++#   les autres URLs du sitemap sont des pages de catégories/villes/activités).
++#   Chaque page détail porte un JSON-LD schema.org VacationRental complet :
++#   occupancy, containsPlace (chambres, sdb, lits par type), petsAllowed,
++#   address (ville, rue, code postal), geo (⚠️ décimales à VIRGULE),
++#   offers.lowPrice (plus bas prix/nuit), images 1080×1080 et licenseNum CITQ.
++#   Les commodités lisibles (FR) viennent des pictos <div class="bulle">.
++#   La note affichée (4,6/1370) est GLOBALE au site : on l'ignore.
++#   Pas de lastmod : clé de cache mensuelle.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import json
++import re
++import time
++
++from ..schema import StListing
++from .base import StConnector
++
++BASE = "https://hebergement-charlevoix.com"
++SITEMAP = BASE + "/sitemap.xml"
++
++_URL_DETAIL = re.compile(
++    r"https://(?:www\.)?hebergement-charlevoix\.com/fr/chalet-a-louer/"
++    r"([\w-]+)/voir/([\w-]+)/?$")
++
++# villes desservies hors de la région touristique de Charlevoix
++_HORS_CHARLEVOIX = {
++    "tadoussac": "Côte-Nord",
++    "saint-ferreol-les-neiges": "Québec",
++    "saint-tite-des-caps": "Québec",
++}
++
++
++def _virgule(v) -> float | None:
++    """Nombre JSON-LD du site : « 47,568534 » (virgule décimale)."""
++    try:
++        return float(str(v).replace(",", "."))
++    except (TypeError, ValueError):
++        return None
++
++
++class HebergementCharlevoix(StConnector):
++    source_id = "hebergementcharlevoix"
++
++    # -- inventaire (sitemap) ----------------------------------------------
++    def _sitemap_urls(self) -> dict[str, tuple[str, str]]:
++        """code -> (url détail, slug ville)."""
++        xml = self.get(SITEMAP).text
++        urls: dict[str, tuple[str, str]] = {}
++        for loc in re.findall(r"<loc>([^<]+)</loc>", xml):
++            m = _URL_DETAIL.match(loc.strip())
++            if m:
++                urls.setdefault(m.group(2), (loc.strip(), m.group(1)))
++        return urls
++
++    # -- page détail (tout est dans le JSON-LD VacationRental) ---------------
++    def _detail(self, url: str) -> dict:
++        h = self.get(url).text
++        d: dict = {}
++        data = None
++        for m in re.finditer(r'<script[^>]*application/ld\+json[^>]*>(.*?)'
++                             r"</script>", h, re.S):
++            try:
++                cand = json.loads(m.group(1), strict=False)
++            except ValueError:
++                continue
++            if isinstance(cand, dict) and cand.get("@type") == "VacationRental":
++                data = cand
++                break
++        if data:
++            d["title"] = (data.get("name") or "").strip()
++            d["description"] = (data.get("description") or "").strip()
++            d["property_type"] = (data.get("additionalType") or "").strip()
++            occ = data.get("occupancy") or {}
++            if occ.get("value") is not None:
++                d["capacity"] = _virgule(occ["value"])
++            place = data.get("containsPlace") or {}
++            if place.get("numberOfBedrooms") is not None:
++                d["bedrooms"] = _virgule(place["numberOfBedrooms"])
++            if place.get("numberOfBathroomsTotal") is not None:
++                d["bathrooms"] = _virgule(place["numberOfBathroomsTotal"])
++            beds = sum(_virgule(b.get("numberOfBeds")) or 0
++                       for b in place.get("bed") or [] if isinstance(b, dict))
++            if beds:
++                d["beds"] = beds
++            if place.get("petsAllowed") is not None:
++                d["pets"] = "oui" if place["petsAllowed"] in (
++                    True, "true", "True", 1) else "non"
++            addr = data.get("address") or {}
++            d["city"] = (addr.get("addressLocality") or "").strip()
++            d["address"] = (addr.get("streetAddress") or "").strip()
++            geo = data.get("geo") or {}
++            d["lat"] = _virgule(geo.get("latitude"))
++            d["lng"] = _virgule(geo.get("longitude"))
++            offers = data.get("offers") or {}
++            low = _virgule(offers.get("lowPrice"))
++            if low:
++                d["price_night"] = round(low, 2)
++                d["price_label"] = f"à partir de {low:.2f} $ / nuit"
++            for feat in data.get("amenityFeature") or []:
++                if not isinstance(feat, dict):
++                    continue
++                if feat.get("name") == "licenseNum":
++                    m2 = re.search(r"(\d{6})", str(feat.get("value") or ""))
++                    if m2 and m2.group(1) != "000000":   # placeholder du site
++                        d["citq"] = m2.group(1)
++            imgs = data.get("image") or []
++            if isinstance(imgs, str):
++                imgs = [imgs]
++            d["images"] = [u for u in imgs if isinstance(u, str)][:20]
++
++        # commodités lisibles : pictos <div class="bulle">Foyer</div>
++        amen = []
++        for a in re.findall(r'<div class="bulle"[^>]*>([^<]+)</div>', h):
++            a = re.sub(r"\s+", " ", a).strip()
++            if a and a not in amen:
++                amen.append(a)
++        if amen:
++            d["amenities"] = amen
++        return d
++
++    # -- contrat --------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        cle = "detail-" + time.strftime("%Y-%m")   # pas de lastmod → mensuel
++        listings: list[StListing] = []
++        for code, (url, ville_slug) in self._sitemap_urls().items():
++            try:
++                d = self.detail(code, cle, lambda u=url: self._detail(u))
++            except Exception:      # une fiche cassée ≠ inventaire perdu
++                d = {}
++            if not d.get("title"):
++                continue
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=code,                 # code interne (ADE-440), stable
++                url=url,
++                title=d["title"],
++                property_type=d.get("property_type") or "Chalet",
++                address=d.get("address", ""),
++                city=d.get("city", ""),
++                region=_HORS_CHARLEVOIX.get(ville_slug, "Charlevoix"),
++                price_night=d.get("price_night"),
++                price_label=d.get("price_label", ""),
++                capacity=d.get("capacity"),
++                bedrooms=d.get("bedrooms"),
++                beds=d.get("beds"),
++                bathrooms=d.get("bathrooms"),
++                pets=d.get("pets"),
++                citq=d.get("citq", ""),
++                description=d.get("description", ""),
++                amenities=d.get("amenities") or [],
++                images=d.get("images") or [],
++                lat=d.get("lat"),
++                lng=d.get("lng"),
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/hebergia.py : Hébergia (hebergia.ca)
++#
++# Agence multi-régions (Cantons-de-l'Est, Laurentides, Lanaudière, Charlevoix,
++# Centre-du-Québec) — WordPress + moteur Guesty, ~60 chalets.
++#
++# Méthode :
++#   1. LISTE : la page /chalets/ embarque `window.chalets = [...]` (JSON
++#      complet : gid Guesty, prix de base/nuit, url, titre, RÉGION, capacité,
++#      chambres, lits, lat/lng, vignette). Une seule requête.
++#   2. DÉTAIL (cache self.detail, clé = champs stables de la liste) : la page
++#      WP fr /chalets/<slug>/ fournit ville (« Austin, Cantons-de-l'Est »),
++#      salles de bain (bloc inshort), description, commodités (section
++#      « Commodités incluses »), photos (assets.guesty.com) et numéro CITQ
++#      (dans le règlement).
++#   External_id = gid (id de listing Guesty, stable).
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import json
++import re
++
++from ..schema import StListing
++from .base import StConnector
++
++SITE = "https://hebergia.ca"
++
++_TAG_RE = re.compile(r"<[^>]+>")
++
++
++def _text(fragment: str) -> str:
++    return _html.unescape(re.sub(r"\s+", " ", _TAG_RE.sub(" ", fragment))).strip()
++
++
++def _num(v) -> float | None:
++    try:
++        return float(v) if v not in (None, "") else None
++    except (TypeError, ValueError):
++        return None
++
++
++class Hebergia(StConnector):
++    source_id = "hebergia"
++
++    # -- liste ----------------------------------------------------------------
++    def _list_items(self) -> list[dict]:
++        h = self.get(f"{SITE}/chalets/").text
++        m = re.search(r"window\.chalets\s*=\s*(\[.*?\]);", h, re.S)
++        if not m:
++            return []
++        try:
++            return json.loads(m.group(1))
++        except ValueError:
++            return []
++
++    # -- page détail ------------------------------------------------------
++    def _detail(self, url: str) -> dict:
++        h = self.get(url).text
++        d: dict = {}
++
++        m = re.search(r'class="sous-titre-localisation">([^<]+)<', h)
++        if m:
++            loc = _text(m.group(1))
++            d["city"] = loc.split(",")[0].strip()
++
++        # bloc « inshort » : 8 voyageurs / 3 chambres / lits / 2 salles de bain
++        m = re.search(r"(\d+)\s*salles?\s*de\s*bain", h)
++        if m:
++            d["bathrooms"] = float(m.group(1))
++
++        # description : paragraphes de l'article avant les accordéons
++        m = re.search(r"(?s)<article class=\"hbg-fiche-chalet-content\">"
++                      r".*?</h1>(.*?)<h2 class=\"toggler\"", h)
++        if m:
++            frag = re.sub(r'(?s)<p class="sous-titre-localisation">.*?</p>',
++                          " ", m.group(1))
++            paras = re.findall(r"(?s)<p[^>]*>(.*?)</p>", frag)
++            d["description"] = " ".join(_text(p) for p in paras
++                                        if _text(p))[:4000]
++
++        # commodités : section « Commodités incluses » (lignes à puces)
++        m = re.search(r'(?s)Commodités incluses</button></h2>\s*'
++                      r'<div class="toToggle"[^>]*>(.*?)</div>', h)
++        if m:
++            amens = []
++            for line in re.split(r"<br\s*/?>|</p>", m.group(1)):
++                t = _text(line).lstrip("•· ").strip()
++                if 2 <= len(t) <= 80 and not t.isupper():
++                    amens.append(t)
++            d["amenities"] = amens[:60]
++
++        # photos (CDN Guesty, dédupliquées)
++        imgs: list[str] = []
++        for u in re.findall(r'data-flickity-lazyload-src="'
++                            r'(https://assets\.guesty\.com/[^"]+)"', h):
++            if u not in imgs:
++                imgs.append(u)
++        d["images"] = imgs[:20]
++
++        m = re.search(r"CITQ\D{0,12}(\d{6})", h, re.I)
++        if m:
++            d["citq"] = m.group(1)
++
++        m = re.search(r"animaux non admis|pas d.animaux|no pets", h, re.I)
++        if m:
++            d["pets"] = "non"
++        return d
++
++    # -- contrat ----------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        listings: list[StListing] = []
++        for it in self._list_items():
++            gid = str(it.get("gid") or "").strip()
++            url = it.get("url") or ""
++            title = _text(str(it.get("title") or ""))
++            if not gid or not url or not title or "/en/" in url:
++                continue
++
++            key = json.dumps([gid, title, it.get("price"),
++                              it.get("accommodates"), it.get("bedrooms"),
++                              it.get("beds"), it.get("shortDesc")],
++                             ensure_ascii=False)
++            try:
++                det = self.detail(gid, key, lambda u=url: self._detail(u))
++            except Exception:      # une fiche détail cassée ≠ annonce perdue
++                det = {}
++
++            price = _num(it.get("price"))
++            starting = _num(it.get("startingPrice"))
++            if starting and starting > 0:
++                price = starting
++            desc = det.get("description") or ""
++            short = _text(str(it.get("shortDesc") or ""))
++            if short and short not in desc:
++                desc = f"{short} {desc}".strip()
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=gid,
++                url=url,
++                title=title,
++                property_type="Chalet",
++                city=det.get("city") or "",
++                region=it.get("region") or "",
++                price_night=price,
++                price_label=(f"à partir de {price:.0f} $ / nuit"
++                             if price else ""),
++                capacity=_num(it.get("accommodates")),
++                bedrooms=_num(it.get("bedrooms")),
++                beds=_num(it.get("beds")),
++                bathrooms=det.get("bathrooms"),
++                pets=det.get("pets"),
++                citq=det.get("citq") or "",
++                description=desc[:4000],
++                amenities=det.get("amenities") or [],
++                details={"guesty_id": gid},
++                images=det.get("images")
++                       or ([it["thumbnail"]] if it.get("thumbnail") else []),
++                lat=_num(it.get("lat")),
++                lng=_num(it.get("lng")),
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/homminichalets.py : HOM Mini Chalets (homminichalets.com) —
++#   12 mini-chalets numérotés (01. Le Renard … 12. Le Loup) à Val-des-Monts
++#   (Outaouais), en deux gammes : « avec spa » (01-08) et « avec circuit
++#   thermal » (09-12, spa + sauna + hammam + douche froide).
++#
++# Méthode : le site Shopify renvoie un 429 systématique en direct → Scrapfly.
++#   1. UIDS : /pages/chalets (rendu JS, le calendrier Hostfully est monté en
++#      JS) → 12 liens /pages/chalets?uid=<uuid> ; la page liste aussi les noms
++#      groupés par gamme (« Mini chalets avec circuit thermal » précède
++#      09-12) et le pied de page porte les 2 adresses + le CITQ commun 298559.
++#   2. DÉTAIL : l'API publique JSONP du moteur Hostfully répond en DIRECT
++#      (pas de 429) : platform.hostfully.com/getproperty_api.jsp?propertyUID=…
++#      &aid=ORB-… → {"price": 300, "maximumGuests": 2, "minStay": 1,
++#      "name": "07. Le Huard"}. Pas d'endpoint photos public → galerie
++#      GÉNÉRIQUE du site (01.jpg-25.jpg de l'accueil, via Scrapfly sans
++#      render_js), signalée par details.images_generic. Commodités/description
++#      par gamme (bandeaux de l'accueil), adresses par numéro d'unité
++#      (07-08 = chemin du Saphir, le reste = chemin du Rubis).
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import json
++import re
++import sys
++
++from ..schema import StListing
++from .base import StConnector
++
++SITE = "https://homminichalets.com"
++LIST_URL = SITE + "/pages/chalets"
++
++# API publique du widget de réservation Hostfully (accessible en direct)
++AID = "ORB-49587220416635719"
++API = ("https://platform.hostfully.com/getproperty_api.jsp"
++       "?jsoncallback=cb&propertyUID={uid}&aid=" + AID)
++
++CITQ = "298559"
++
++# gammes (bandeaux de l'accueil) : commodités + description
++_SPA_AMEN = ["Spa privé", "Chaise hamac", "Lit King",
++             "Foyer intérieur", "Plancher chauffant"]
++_SPA_DESC = ("Mini chalet avec spa. Profitez d'un mini chalet de luxe tout "
++             "équipé avec spa privé sur la galerie, foyer intérieur et "
++             "plancher chauffant.")
++_THERMAL_AMEN = ["Spa", "Sauna", "Hammam", "Douche froide", "Lit Queen",
++                 "Foyer intérieur", "Plancher chauffant"]
++_THERMAL_DESC = ("Mini chalet avec circuit thermal (spa, sauna, hammam, "
++                 "douche froide). Vivez une expérience de détente privée et "
++                 "luxueuse dans un mini chalet tout équipé avec foyer "
++                 "intérieur et plancher chauffant.")
++
++
++class HomMiniChalets(StConnector):
++    source_id = "homminichalets"
++    request_delay = 1.0
++
++    # -- découverte des uids (Scrapfly, calendrier monté en JS) ---------------
++    def _uids(self) -> list[str]:
++        h = self.get_scrapfly(LIST_URL, render_js=True, rendering_wait=4000)
++        uids: list[str] = []
++        for u in re.findall(r'href="[^"]*?/pages/chalets\?uid='
++                            r'([0-9a-f-]{36})"', h):
++            if u not in uids:
++                uids.append(u)
++        return uids
++
++    # -- galerie générique du site (accueil Shopify statique) -----------------
++    def _site_images(self) -> list[str]:
++        try:
++            h = self.get_scrapfly(SITE + "/", render_js=False)
++        except Exception as exc:  # noqa: BLE001
++            print(f"[homminichalets] accueil : {exc}", file=sys.stderr)
++            return []
++        imgs: list[str] = []
++        for num, v in re.findall(r"//homminichalets\.com/cdn/shop/files/"
++                                 r"(\d{2}\.jpg)\?v=(\d+)", h):
++            u = f"{SITE}/cdn/shop/files/{num}?v={v}&width=1600"
++            if u not in imgs:
++                imgs.append(u)
++        return imgs[:15]
++
++    # -- fiche Hostfully (JSONP, en direct) ------------------------------------
++    def _detail(self, uid: str) -> dict:
++        txt = self.get(API.format(uid=uid)).text.strip()
++        m = re.match(r"(?s)cb\(true,(\{.*\})\)$", txt)
++        return json.loads(m.group(1)) if m else {}
++
++    # -- contrat ---------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        uids = self._uids()
++        images = self._site_images() if uids else []
++
++        listings: list[StListing] = []
++        for uid in uids:
++            det = self.detail(uid, "v1", lambda u=uid: self._detail(u))
++            name = str(det.get("name") or "").strip()
++            if not name:
++                continue
++
++            m = re.match(r"(\d{1,2})\.", name)
++            num = int(m.group(1)) if m else 0
++            thermal = num >= 9
++            address = ("32 chemin du Saphir" if num in (7, 8)
++                       else "154 chemin du Rubis")
++
++            price = det.get("price")
++            price = float(price) if price and 20 <= float(price) <= 20000 \
++                else None
++
++            details = {
++                "gamme": ("circuit thermal" if thermal else "spa"),
++                "domain": "HOM Mini Chalets",
++            }
++            if images:
++                details["images_generic"] = True
++            if det.get("minStay"):
++                details["min_stay"] = f"{det['minStay']} nuit(s)"
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=uid,
++                url=f"{LIST_URL}?uid={uid}",
++                title=f"{name} — HOM Mini Chalets",
++                property_type="Mini-chalet",
++                address=address,
++                city="Val-des-Monts",
++                region="Outaouais",
++                price_night=price,
++                price_label=(f"à partir de {price:g} $ / nuit"
++                             if price else ""),
++                capacity=(float(det["maximumGuests"])
++                          if det.get("maximumGuests") else None),
++                bedrooms=1.0,
++                citq=CITQ,
++                description=_THERMAL_DESC if thermal else _SPA_DESC,
++                amenities=list(_THERMAL_AMEN if thermal else _SPA_AMEN),
++                details=details,
++                images=list(images),
++            ))
++        return listings

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

				`@@ -20,11 +20,18 @@`
20	#	20	#
21	# Filtres court terme : on ne garde que les annonces OFFER qui ressemblent à	21	# Filtres court terme : on ne garde que les annonces OFFER qui ressemblent à
22	# un hébergement (attributs chambres/personnes/type de vacances présents —	22	# un hébergement (attributs chambres/personnes/type de vacances présents —
23	−# la catégorie contient aussi maillots de bain, machines à espresso…) et on	23	+# la catégorie contient aussi maillots de bain, machines à espresso… ; si
24	−# écarte les locations au mois (« 31 jours et plus », monthly…). Le prix	24	+# les attributs manquent sur la liste mais que le titre évoque un
25	−# Kijiji est un montant sans période : price_night n'est rempli que si le	25	+# hébergement, la fiche détail tranche) et on écarte les locations au mois
26	−# texte précise « /nuit » ou « /semaine », sinon le montant affiché va dans	26	+# (« 31 jours et plus », monthly, minnights >= 28…).
27	−# details.prix_affiche.	27	+#
		28	+# Prix : le formulaire de la catégorie demande un prix À LA NUIT — un texte
		29	+# « X $/nuit » ou « $X/night » dans l'annonce prime (minimum des saisons),
		30	+# sinon le montant affiché est pris comme prix/nuit s'il est plausible
		31	+# (<= 2 000 $ et séjour min < 28 nuits), sinon details.prix_affiche.
		32	+# Salles de bain : la valeur canonique Kijiji est en dixièmes (« 20 » = 2) —
		33	+# normalisée. Commodités : aucune dans les attributs de la catégorie — on
		34	+# les dérive des mentions explicites du texte (spa, sauna, foyer, BBQ…).
28	#	35	#
29	# Réglage env : LOUKA_KIJIJI_LIMIT (nb max d'annonces, pour tester petit).	36	# Réglage env : LOUKA_KIJIJI_LIMIT (nb max d'annonces, pour tester petit).
30	# -----------------------------------------------------------------------------	37	# -----------------------------------------------------------------------------
				`@@ -37,6 +44,7 @@ import time`
37		44
38	import requests	45	import requests
39		46
		47	+from ...normalize import strip_accents
40	from ..schema import StListing, normalize_region, parse_price_night, REGIONS	48	from ..schema import StListing, normalize_region, parse_price_night, REGIONS
41	from .airbnb import _region_from_latlng	49	from .airbnb import _region_from_latlng
42	from .base import StConnector	50	from .base import StConnector
				`@@ -54,10 +62,54 @@ _MENSUEL_RE = re.compile(`
54	r"au mois\|par mois\|/\smois\|mensuel\|monthly\|per\s+month\|/\smonth"	62	r"au mois\|par mois\|/\smois\|mensuel\|monthly\|per\s+month\|/\smonth"
55	r"\|3[01]\sjours\s(?:et plus\|minimum\|min)\|month(?:ly)?\s+rental", re.I)	63	r"\|3[01]\sjours\s(?:et plus\|minimum\|min)\|month(?:ly)?\s+rental", re.I)
56		64
57	−_NUIT_RE = re.compile(r"(\d[\d\s,.]{0,9})\s\$\s(?:/\|par\|la\|per)?\s*"	65	+# « 265 $ / nuit » (fr) comme « $265/night » (en) — $ avant ou après le montant
58	− r"(?:nuit\|night)", re.I)	66	+_NUIT_RE = re.compile(
59	−_SEMAINE_RE = re.compile(r"(\d[\d\s,.]{0,9})\s\$\s(?:/\|par\|la\|per)?\s*"	67	+ r"(?:\$\s(\d[\d\s,.]{0,8}\d\|\d)\|(\d[\d\s,.]{0,8}\d\|\d)\s\$)\s*"
60	− r"(?:sem(?:aine)?\|week)", re.I)	68	+ r"(?:/\|par\|la\|per)?\s*(?:nuit\|night)", re.I)
		69	+_SEMAINE_RE = re.compile(
		70	+ r"(?:\$\s(\d[\d\s,.]{0,8}\d\|\d)\|(\d[\d\s,.]{0,8}\d\|\d)\s\$)\s*"
		71	+ r"(?:/\|par\|la\|per)?\s*(?:sem(?:aine)?\|week)", re.I)
		72	+
		73	+
		74	+def _prix_min(texte: str, rx: re.Pattern) -> float \| None:
		75	+ """Le plus bas des montants d'une période (les annonces listent souvent
		76	+ plusieurs saisons : « $265/night … $298/night »)."""
		77	+ vals = []
		78	+ for m in rx.finditer(texte or ""):
		79	+ raw = (m.group(1) or m.group(2) or "").strip()
		80	+ v = parse_price_night(f"{raw} $")
		81	+ if v:
		82	+ vals.append(v)
		83	+ return min(vals) if vals else None
		84	+
		85	+
		86	+# mentions explicites du texte → commodité affichable (la catégorie Kijiji
		87	+# n'a aucun attribut de commodités) ; clés en minuscules sans accents
		88	+_AMEN_HINTS = [
		89	+ ("spa", "Spa"), ("jacuzzi", "Spa"), ("hot tub", "Spa"),
		90	+ ("sauna", "Sauna"), ("piscine", "Piscine"), ("pool", "Piscine"),
		91	+ ("foyer", "Foyer"), ("fireplace", "Foyer"),
		92	+ ("poele a bois", "Poêle à bois"), ("wood stove", "Poêle à bois"),
		93	+ ("bbq", "BBQ"), ("barbecue", "BBQ"),
		94	+ ("wifi", "Wi-Fi"), ("wi-fi", "Wi-Fi"), ("internet", "Wi-Fi"),
		95	+ ("lave-vaisselle", "Lave-vaisselle"), ("dishwasher", "Lave-vaisselle"),
		96	+ ("laveuse", "Laveuse/sécheuse"), ("washer", "Laveuse/sécheuse"),
		97	+ ("climatis", "Air climatisé"), ("air conditioning", "Air climatisé"),
		98	+ ("kayak", "Kayak"), ("canot", "Canot"), ("canoe", "Canot"),
		99	+ ("stationnement", "Stationnement"), ("parking", "Stationnement"),
		100	+ ("bord de l'eau", "Bord de l'eau"), ("bord du lac", "Bord de l'eau"),
		101	+ ("waterfront", "Bord de l'eau"), ("lakefront", "Bord de l'eau"),
		102	+ ("plage", "Plage à proximité"), ("beach", "Plage à proximité"),
		103	+]
		104	+
		105	+
		106	+def _amenities_texte(texte: str) -> list[str]:
		107	+ hay = strip_accents(texte or "").lower().replace("’", "'")
		108	+ out: list[str] = []
		109	+ for needle, label in _AMEN_HINTS:
		110	+ if needle in hay and label not in out:
		111	+ out.append(label)
		112	+ return out
61		113
62	_TYPE_HINTS = [	114	_TYPE_HINTS = [
63	("chalet", "Chalet"), ("cottage", "Chalet"), ("cabin", "Chalet"),	115	("chalet", "Chalet"), ("cottage", "Chalet"), ("cabin", "Chalet"),
				`@@ -80,6 +132,16 @@ def _num(texts: list[str]) -> float \| None:`
80	return None	132	return None
81		133
82		134
		135	+def _sdb(attrs: dict) -> float \| None:
		136	+ """Salles de bain : la valeur canonique Kijiji est en dixièmes
		137	+ (« 20 » = 2, « 25 » = 2,5) ; la valeur humaine (« 2 bathrooms ») est
		138	+ déjà correcte."""
		139	+ v = _num(attrs.get("numberbathrooms"))
		140	+ if v is not None and v >= 10 and v % 5 == 0:
		141	+ v /= 10
		142	+ return v
		143	+
		144	+
83	def _attrs(entity: dict) -> dict[str, list[str]]:	145	def _attrs(entity: dict) -> dict[str, list[str]]:
84	"""{canonicalName: values (humaines si présentes, sinon canoniques)}."""	146	"""{canonicalName: values (humaines si présentes, sinon canoniques)}."""
85	out: dict[str, list[str]] = {}	147	out: dict[str, list[str]] = {}
				`@@ -212,7 +274,9 @@ class KijijiCt(StConnector):`
212	if (e.get("type") or "OFFER") != "OFFER":	274	if (e.get("type") or "OFFER") != "OFFER":
213	continue	275	continue
214	attrs = _attrs(e)	276	attrs = _attrs(e)
215	− if not (_ATTRS_HEBERGEMENT & set(attrs)):	277	+ hay = title.lower()
		278	+ if not (_ATTRS_HEBERGEMENT & set(attrs)) \
		279	+ and not any(n in hay for n, _ in _TYPE_HINTS):
216	continue # maillots de bain, cafetières, vans…	280	continue # maillots de bain, cafetières, vans…
217	texte = f"{title}\n{e.get('description') or ''}"	281	texte = f"{title}\n{e.get('description') or ''}"
218	if _MENSUEL_RE.search(texte):	282	if _MENSUEL_RE.search(texte):
				`@@ -228,30 +292,35 @@ class KijijiCt(StConnector):`
228	det = {}	292	det = {}
229	if det.get("attrs"):	293	if det.get("attrs"):
230	attrs = det["attrs"]	294	attrs = det["attrs"]
		295	+ if not (_ATTRS_HEBERGEMENT & set(attrs)):
		296	+ continue # le détail confirme : pas un hébergement
231	texte = (f"{title}\n"	297	texte = (f"{title}\n"
232	f"{det.get('description') or e.get('description') or ''}")	298	f"{det.get('description') or e.get('description') or ''}")
233	if _MENSUEL_RE.search(texte):	299	if _MENSUEL_RE.search(texte):
234	continue	300	continue
		301	+ nuits_min = _num(attrs.get("minnights")) or 0
		302	+ if nuits_min >= 28:
		303	+ continue # séjour min d'un mois : hors mandat
235		304
236	− # prix : montant en cents, période seulement si le texte la donne	305	+ # prix : « X $/nuit » du texte (minimum des saisons) prime ;
		306	+ # sinon le montant affiché (en cents) est un prix à la nuit
		307	+ # (convention de la catégorie) s'il est plausible
237	price_night = None	308	price_night = None
238	price_label = ""	309	price_label = ""
239	amount = (e.get("price") or {}).get("amount")	310	amount = (e.get("price") or {}).get("amount")
240	montant = round(amount / 100, 2) if isinstance(	311	montant = round(amount / 100, 2) if isinstance(
241	amount, (int, float)) and amount else None	312	amount, (int, float)) and amount else None
242	− m = _NUIT_RE.search(texte)	313	+ nuit_val = _prix_min(texte, _NUIT_RE)
243	− if m:	314	+ sem_val = _prix_min(texte, _SEMAINE_RE)
244	− price_label = f"{m.group(1).strip()} $ / nuit"	315	+ if nuit_val:
245	− elif _SEMAINE_RE.search(texte):	316	+ price_night = nuit_val
246	− price_label = f"{_SEMAINE_RE.search(texte).group(1).strip()}" \	317	+ price_label = f"{nuit_val:g} $ / nuit"
247	− " $ / semaine"	318	+ elif sem_val:
248	− elif montant:	319	+ price_night = round(sem_val / 7, 2)
249	− nuit = (attrs.get("minnights") or ["1"])[0]	320	+ price_label = f"{sem_val:g} $ / semaine"
250	− if str(nuit) in ("", "1"): # 1 nuit min : montant ≈ par nuit	321	+ elif montant and montant <= 2000:
251	− price_night = montant	322	+ price_night = montant
252	− price_label = f"{montant:g} $"	323	+ price_label = f"{montant:g} $"
253	− if price_label and price_night is None:
254	− price_night = parse_price_night(price_label)
255		324
256	hay = title.lower()	325	hay = title.lower()
257	ptype = next((canon for needle, canon in _TYPE_HINTS	326	ptype = next((canon for needle, canon in _TYPE_HINTS
				`@@ -302,9 +371,10 @@ class KijijiCt(StConnector):`
302	price_label=price_label,	371	price_label=price_label,
303	capacity=_num(attrs.get("maxpeople")),	372	capacity=_num(attrs.get("maxpeople")),
304	bedrooms=_num(attrs.get("numberbedrooms")),	373	bedrooms=_num(attrs.get("numberbedrooms")),
305	− bathrooms=_num(attrs.get("numberbathrooms")),	374	+ bathrooms=_sdb(attrs),
306	pets=pets,	375	pets=pets,
307	description=det.get("description") or "",	376	description=det.get("description") or "",
		377	+ amenities=_amenities_texte(texte),
308	details=details,	378	details=details,
309	images=det.get("images")	379	images=det.get("images")
310	or [u for u in (e.get("imageUrls") or [])	380	or [u for u in (e.get("imageUrls") or [])

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/lesversants.py : Les Versants Mont-Tremblant (lesversants.com) —
++#   agence immobilière de Mont-Tremblant dont la division location propose
++#   ~16 maisons et condos en location saisonnière (Mont-Tremblant,
++#   Lac-Supérieur, Mont-Blanc).
++#
++# Méthode : le sitemap.xml est un vestige statique (2 URLs), mais le thème
++#   WordPress REAL_HOMES expose tout via l'API REST :
++#     GET /fr/wp-json/wp/v2/property?property-status=79&per_page=100
++#   (79 = terme « À louer » de la taxonomie property-status). Chaque fiche
++#   embarque property_meta REAL_HOMES_* : adresse, lat/lng, chambres, salles
++#   de bain (formats « 3 + 1 »), superficie, galerie (sizes.large), prix.
++#   ⚠️ PRIX SAISONNIER : le prix affiché est « Hiver 2026-27 | 18 500 $ »
++#   (un forfait pour LA SAISON, pas à la nuit) → on le range dans
++#   details.season_price et on laisse price_night/price_label vides pour ne
++#   pas empoisonner parse_price_night().
++#   Taxonomies property-type (439 Condo à louer, 440/441 maisons), city et
++#   mont_tremblant_sector résolues par une passe chacune.
++#
++# Réglage env : LOUKA_LESVERSANTS_LIMIT (nb max d'annonces, 0 = tout).
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import os
++import re
++
++from ..schema import StListing
++from .base import StConnector
++
++API = "https://lesversants.com/fr/wp-json/wp/v2"
++STATUS_A_LOUER = 79  # terme « À louer » (property-status)
++
++# id property-type → type canonique
++_TYPES = {439: "Condo", 440: "Maison", 441: "Maison"}
++
++_TAG_RE = re.compile(r"<[^>]+>")
++
++
++def _strip_html(txt: str) -> str:
++    return re.sub(r"\s+", " ", _TAG_RE.sub(" ", _html.unescape(txt or ""))).strip()
++
++
++def _rooms(v: str) -> float | None:
++    """« 3 », « 3 + 1 », « 3.5 » → nombre (les « + N » sont additionnés)."""
++    nums = re.findall(r"\d+(?:\.\d+)?", str(v or ""))
++    return sum(float(n) for n in nums) if nums else None
++
++
++class LesVersants(StConnector):
++    source_id = "lesversants"
++    request_delay = 0.5
++
++    def _get_json(self, url: str):
++        return self.get(url, headers={"Accept": "application/json"}).json()
++
++    def _tax(self, name: str) -> dict[int, str]:
++        try:
++            terms = self._get_json(f"{API}/{name}?per_page=100"
++                                   "&_fields=id,name")
++            return {t["id"]: _html.unescape(t.get("name") or "").strip()
++                    for t in terms}
++        except Exception:  # noqa: BLE001 — libellés manquants ≠ blocage
++            return {}
++
++    # -- contrat --------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        limit = int(os.environ.get("LOUKA_LESVERSANTS_LIMIT", "0") or 0)
++        items = self._get_json(f"{API}/property?property-status="
++                               f"{STATUS_A_LOUER}&per_page=100")
++        if not isinstance(items, list):
++            return []
++        if limit:
++            items = items[:limit]
++
++        types = self._tax("property-type")
++        cities = self._tax("city")
++        sectors = self._tax("mont_tremblant_sector")
++
++        listings: list[StListing] = []
++        seen: set[str] = set()
++        for it in items:
++            pid = str(it.get("id") or "").strip()
++            url = (it.get("link") or "").strip()
++            title = _strip_html((it.get("title") or {}).get("rendered") or "")
++            if not pid or pid in seen or not url or not title:
++                continue
++            seen.add(pid)
++
++            meta = it.get("property_meta") or {}
++            loc = meta.get("REAL_HOMES_property_location") or {}
++            lat = float(loc["latitude"]) if loc.get("latitude") else None
++            lng = float(loc["longitude"]) if loc.get("longitude") else None
++
++            type_ids = it.get("property-type") or []
++            ptype = next((_TYPES[t] for t in type_ids if t in _TYPES), "")
++            if not ptype:
++                ptype = next((types[t] for t in type_ids if t in types), "")
++
++            city_ids = it.get("city") or []
++            city = next((cities[c] for c in city_ids if c in cities),
++                        "Mont-Tremblant")
++            sector_ids = it.get("mont_tremblant_sector") or []
++            sector = next((sectors[s] for s in sector_ids if s in sectors), "")
++
++            # prix SAISONNIER (« Hiver 2026-27 | 18 500 $ ») → details
++            prefix = (meta.get("REAL_HOMES_property_price_prefix") or "").strip()
++            raw_price = re.sub(r"[^\d.]", "",
++                               str(meta.get("REAL_HOMES_property_price") or ""))
++            season_price = ""
++            if raw_price:
++                season = prefix.rstrip("|").strip()
++                season_price = (f"{season} : {raw_price} $" if season
++                                else f"{raw_price} $")
++
++            size = (meta.get("REAL_HOMES_property_size") or "").strip()
++            size_post = (meta.get("REAL_HOMES_property_size_postfix")
++                         or "").strip()
++
++            images: list[str] = []
++            for ph in meta.get("REAL_HOMES_property_images") or []:
++                sizes = (ph or {}).get("sizes") or {}
++                u = ((sizes.get("1536x1536") or {}).get("url")
++                     or (sizes.get("large") or {}).get("url")
++                     or (sizes.get("medium_large") or {}).get("url") or "")
++                if u.startswith("https://") and u not in images:
++                    images.append(u)
++                if len(images) >= 15:
++                    break
++
++            details = {k: v for k, v in {
++                "season_price": season_price,
++                "sector": sector,
++                "size": f"{size} {size_post}".strip() if size else "",
++            }.items() if v}
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=pid,
++                url=url,
++                title=title,
++                property_type=ptype,
++                address=(meta.get("REAL_HOMES_property_address") or "").strip(),
++                city=city,
++                region="Laurentides",
++                bedrooms=_rooms(meta.get("REAL_HOMES_property_bedrooms")),
++                bathrooms=_rooms(meta.get("REAL_HOMES_property_bathrooms")),
++                description=_strip_html((it.get("content") or {})
++                                        .get("rendered") or "")[:3000],
++                details=details,
++                images=images,
++                lat=lat,
++                lng=lng,
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/locationdechalets.py : Location de Chalets Lanaudière
++#   (locationdechalets.com) — petit parc de ~10 chalets avec spa privé à
++#   Notre-Dame-de-la-Merci et Saint-Donat (Lanaudière).
++#
++# Méthode : sitemap.xml → /fr/chalets/<slug>/ + lastmod (clé du cache détail).
++#   Pages statiques (CMS maison) riches mais sans JSON-LD :
++#     - h1 « Chalet Spa Le Héron … Capacité de 2 personnes » ;
++#     - bloc CARACTÉRISTIQUES (« N personnes maximum / N chambre(s) /
++#       N salle(s) de bain ») ;
++#     - sections INTÉRIEUR / EXTÉRIEUR / INCLUS en <ul><li> → amenities ;
++#     - « EN SUS … Animaux : 10 $ / jour » → pets = conditions ;
++#     - bloc Coordonnées (rue, ville, « Lanaudière (Québec) », code postal) ;
++#     - no CITQ dans le pied de page ; lat/lng dans le lien Google Maps (@…) ;
++#     - TARIF RÉGULIER « 2 nuits : 498 $ … » → price_night = total/2 nuits.
++#       ⚠️ anti-scrape : zéros de bourrage blancs sur blanc
++#       (<span style='color: #ffffff;'>0</span>) à retirer AVANT le parsing ;
++#     - galerie : background:url(/fichiersUploadOpt/…) du slider.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import re
++
++from ..schema import StListing
++from .base import StConnector
++
++SITE = "https://www.locationdechalets.com"
++SITEMAP = SITE + "/sitemap.xml"
++
++_TAG_RE = re.compile(r"<[^>]+>")
++
++# ville → région (repli quand la ligne « … (Québec) » manque)
++_CITY_REGION = {
++    "chute-st-philippe": "Laurentides",
++    "chute-saint-philippe": "Laurentides",
++    "la macaza": "Laurentides",
++    "val-david": "Laurentides",
++    "notre-dame-de-la-merci": "Lanaudière",
++    "saint-donat": "Lanaudière",
++    "st-donat": "Lanaudière",
++}
++
++
++def _text(fragment: str) -> str:
++    return _html.unescape(re.sub(r"\s+", " ", _TAG_RE.sub(" ", fragment))).strip()
++
++
++class LocationDeChalets(StConnector):
++    source_id = "locationdechalets"
++    request_delay = 1.0
++
++    # -- page détail ----------------------------------------------------------
++    def _detail(self, url: str) -> dict:
++        h = self.get(url).text
++        d: dict = {}
++
++        m = re.search(r"(?s)<h1[^>]*>(.*?)</h1>", h)
++        if m:
++            d["title"] = _text(re.split(r"<br\s*/?>", m.group(1))[0])
++        # « Capacité de 2 personnes » / « Capacité de 2 à 4 personnes » (max)
++        m = re.search(r"Capacité de (?:\d+\s+à\s+)?(\d+) personnes", h)
++        if m:
++            d["capacity"] = int(m.group(1))
++
++        # description : après <strong>Description</strong>, jusqu'à la
++        # section suivante ; certaines pages n'ont pas ce marqueur → repli
++        # sur le plus long <p> éditorial
++        m = re.search(r"(?s)<strong>Description</strong>(.*?)"
++                      r"(?:CARACTÉRISTIQUES|Caractéristiques|Disponibilités"
++                      r"|<strong>INTÉRIEUR)", h)
++        if m:
++            texte = re.sub(r"<br\s*/?>", "\n", m.group(1))
++            texte = _html.unescape(_TAG_RE.sub(" ", texte))
++            texte = re.sub(r"[ \t]+", " ", texte)
++            texte = re.sub(r"\n\s+", "\n", texte).strip()
++            d["description"] = texte[:5000]
++        else:
++            paras = [_text(p) for p in
++                     re.findall(r"(?s)<p[^>]*>(.*?)</p>", h)]
++            paras = [p for p in paras if len(p) > 150
++                     and "Coordonnées" not in p
++                     and "Contactez-nous" not in p
++                     and "Découvrez nos chalets" not in p]
++            if paras:
++                d["description"] = max(paras, key=len)[:5000]
++
++        # sections (deux styles : MAJUSCULES ou « Caractéristiques : ») :
++        # <ul> qui suit chaque entête → amenities + compteurs
++        amen: list[str] = []
++        for sec in (r"CARACT[EÉ]RISTIQUES", r"INT[EÉ]RIEUR",
++                    r"EXT[EÉ]RIEUR", r"INCLUS"):
++            for m in re.finditer(sec, h, re.I):
++                mu = re.search(r"(?s)<ul[^>]*>(.*?)</ul>",
++                               h[m.start():m.start() + 3500])
++                if not mu:
++                    continue
++                for li in re.findall(r"(?s)<li[^>]*>(.*?)</li>", mu.group(1)):
++                    t = _text(li)
++                    if t and t not in amen:
++                        amen.append(t)
++                break
++        # compteurs extraits des puces (« 2 chambres (1 lit queen…) »,
++        # « 1 salle de bain », « 2 personnes maximum ») + du texte qui suit
++        # l'entête CARACTÉRISTIQUES (pages où ce sont des <p>, pas des <li>)
++        blob = " | ".join(amen)
++        m = re.search(r"CARACT[EÉ]RISTIQUES", h, re.I)
++        if m:
++            blob += " | " + _text(h[m.start():m.start() + 700])
++        m = re.search(r"(\d+)\s+personnes?\s+maximum", blob)
++        if m:
++            d.setdefault("capacity", int(m.group(1)))
++        m = re.search(r"(\d+(?:[.,]5)?)\s+chambres?", blob)
++        if m:
++            d["bedrooms"] = float(m.group(1).replace(",", "."))
++        m = re.search(r"(\d+(?:[.,]5)?)\s+salles?\s+de\s+bain", blob)
++        if m:
++            d["bathrooms"] = float(m.group(1).replace(",", "."))
++        amen = [a for a in amen
++                if not re.fullmatch(r"\d+\s+(personnes?\s+maximum"
++                                    r"|chambres?|salles?\s+de\s+bain)", a)]
++        if amen:
++            d["amenities"] = amen
++
++        # frais : « Animaux : 10 $ / jour » (section EN SUS)
++        m = re.search(r"Animaux\s*:\s*([\d,]+\s*\$[^<]*)", h)
++        if m:
++            d["pets_fee"] = _text(m.group(1))
++
++        # coordonnées : rue / ville / « Lanaudière (Québec) » / code postal
++        m = re.search(r"(?s)<div class=\"coord[^\"]*\"[^>]*>(.*?)</div>", h)
++        if m:
++            lines = [_text(x) for x in re.split(r"<br\s*/?>|</p>", m.group(1))]
++            lines = [x for x in lines if x and "Coordonnées" not in x
++                     and not re.fullmatch(r"[\d,]+", x)]
++            reg = next((x for x in lines if "(Québec)" in x), "")
++            if reg:
++                j = lines.index(reg)
++                d["region"] = reg.split("(")[0].strip()
++                if j >= 1:
++                    d["city"] = lines[j - 1].strip(", ")
++                if j >= 2:
++                    d["address"] = lines[j - 2].strip(", ")
++                if j + 1 < len(lines):
++                    d["postal_code"] = lines[j + 1]
++            else:
++                # variante sans ligne « … (Québec) » : rue / ville / postal
++                postal = next((x for x in lines
++                               if re.fullmatch(r"[A-Z]\d[A-Z]\s?\d[A-Z]\d",
++                                               x.strip())), "")
++                rest = [x for x in lines if x != postal]
++                if len(rest) >= 2:
++                    d["address"] = rest[0].strip(", ")
++                    d["city"] = rest[1].strip(", ")
++                if postal:
++                    d["postal_code"] = postal.strip()
++
++        # (pas de lat/lng : le lien Google Maps pointe l'agence, pas le
++        # chalet — le géocodage se fera en aval sur adresse+ville)
++        m = re.search(r"CITQ\D{0,25}(\d{6})", h)
++        if m:
++            d["citq"] = m.group(1)
++
++        # TARIF RÉGULIER : « 2 nuits : 498 $ » (en <p> ou en <table>) →
++        # 249 $/nuit. ⚠️ anti-scrape : chiffres de bourrage blancs sur blanc,
++        # PARFOIS IMBRIQUÉS (<span #fff>0<span #000>4</span></span>98) → on
++        # élimine itérativement les <span> les plus internes : blancs = jetés
++        # avec leur contenu, autres = dépliés (contenu conservé).
++        i = h.find("TARIF RÉGULIER")
++        if i >= 0:
++            frag = h[i:i + 2500]
++            for _ in range(20):
++                frag2 = re.sub(
++                    r"<span([^>]*)>([^<]*)</span>",
++                    lambda m: (m.group(2).replace("0", "")
++                               if re.search(r"color:\s*#f{3,6}\b",
++                                            m.group(1), re.I)
++                               else m.group(2)),
++                    frag)
++                if frag2 == frag:
++                    break
++                frag = frag2
++            frag = _text(frag)
++            m = re.search(r"(\d+)\s*nuits?\s*:\s*(\d[\d\s]*)\s*\$", frag)
++            if m:
++                nights = int(m.group(1))
++                total = float(m.group(2).replace(" ", ""))
++                if nights and 20 <= total / nights <= 20000:
++                    d["price_night"] = round(total / nights)
++                    d["price_ref"] = f"{nights} nuits : {total:g} $"
++
++        # galerie du slider
++        imgs: list[str] = []
++        for u in re.findall(r"background:\s*url\(([^)]+)\)", h):
++            u = u.strip("'\" ")
++            if u.startswith("/fichiersUploadOpt/"):
++                u = SITE + u
++            if u.startswith("https://") and u not in imgs:
++                imgs.append(u)
++            if len(imgs) >= 20:
++                break
++        if imgs:
++            d["images"] = imgs
++        return d
++
++    # -- contrat --------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        xml = self.get(SITEMAP).text
++        entries = re.findall(r"(?s)<url>\s*<loc>([^<]+)</loc>"
++                             r"(?:\s*<lastmod>([^<]*)</lastmod>)?", xml)
++
++        listings: list[StListing] = []
++        vus: set[str] = set()
++        for url, lastmod in entries:
++            m = re.match(r"https://www\.locationdechalets\.com/fr/chalets/"
++                         r"([^/]+)/?$", url)
++            if not m:
++                continue
++            slug = m.group(1)
++            if slug in vus:
++                continue
++            vus.add(slug)
++
++            det = self.detail(slug, lastmod or "v1",
++                              lambda u=url: self._detail(u))
++            title = det.get("title") or ""
++            if not title:
++                continue
++
++            city = det.get("city") or ""
++            region = det.get("region") \
++                or _CITY_REGION.get(city.lower(), "Lanaudière")
++
++            price = det.get("price_night")
++            details = {k: v for k, v in {
++                "postal_code": det.get("postal_code") or "",
++                "price_ref": det.get("price_ref") or "",
++                "pets_fee": det.get("pets_fee") or "",
++            }.items() if v}
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=slug,
++                url=url,
++                title=title,
++                property_type="Chalet",
++                address=det.get("address") or "",
++                city=city,
++                region=region,
++                price_night=float(price) if price else None,
++                price_label=f"à partir de {price:g} $ / nuit" if price else "",
++                capacity=float(det["capacity"]) if det.get("capacity") else None,
++                bedrooms=det.get("bedrooms"),
++                bathrooms=det.get("bathrooms"),
++                pets="conditions" if det.get("pets_fee") else None,
++                citq=det.get("citq") or "",
++                description=det.get("description") or "",
++                amenities=det.get("amenities") or [],
++                details=details,
++                images=det.get("images") or [],
++                lat=det.get("lat"),
++                lng=det.get("lng"),
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/memoriachalets.py : Memoria Chalets (memoriachalets.com)
++#   — gestionnaire de Magog, ~110 fiches FR (Cantons-de-l'Est surtout,
++#   quelques Laurentides / Centre-du-Québec).
++#
++# Méthode : WordPress, CPT `cpt_chalets`, HTML serveur. Sitemap
++#   /cpt_chalets-sitemap.xml (lastmod fiable ; doublons /en/ écartés) →
++#   pages /locations/<slug>/. La fiche est balisée par classes :
++#   h2.location-title (« Le Hibou – Magog »), p.location-specs
++#   (« 4 CHAMBRES - 1.5 SALLES DE BAIN - 8 PERSONNES »), p.location-adress
++#   (adresse complète), p.starting-price (« À partir de 199,00$ par jour » —
++#   une partie du parc est au mois/31 jours minimum : prix nuit alors absent,
++#   la mention est conservée dans details), p.citq (« CITQ #296459 … » ou
++#   « (Location minimum de 31 jours) ») et ul de .accomosdations-filters
++#   (commodités, dont « Animaux interdit/admis »). Pas de géo dans le HTML.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import re
++
++from bs4 import BeautifulSoup
++
++from ...normalize import strip_accents
++from ..schema import StListing, parse_price_night
++from .base import StConnector
++
++SITEMAP = "https://memoriachalets.com/cpt_chalets-sitemap.xml"
++
++_URL_DETAIL = re.compile(
++    r"https://(?:www\.)?memoriachalets\.com/locations/([\w%-]+)/?$")
++
++_SPECS_RE = re.compile(
++    r"([\d.,]+)\s*CHAMBRES?\s*[-·—]\s*([\d.,]+)\s*SALLES?\s+DE\s+BAIN"
++    r"\s*[-·—]\s*([\d.,]+)\s*PERSONNES?", re.I)
++
++_CP_RE = re.compile(r"^[A-Za-z]\d[A-Za-z]\s?\d[A-Za-z]\d$")   # code postal
++
++# mot-clé (titre) → type canonique ; défaut : Chalet
++_TYPE_HINTS = [("condo", "Condo"), ("appartement", "Appartement"),
++               ("apt", "Appartement"), ("loft", "Loft"), ("studio", "Studio"),
++               ("maison", "Maison")]
++
++# indices de région dans le texte (leur parc : Estrie surtout)
++_REGION_HINTS = [
++    ("estrie", "Cantons-de-l'Est"), ("cantons-de-l'est", "Cantons-de-l'Est"),
++    ("laurentides", "Laurentides"), ("lanaudiere", "Lanaudière"),
++    ("centre-du-quebec", "Centre-du-Québec"), ("mauricie", "Mauricie"),
++    ("charlevoix", "Charlevoix"), ("monteregie", "Montérégie"),
++]
++
++# villes connues du parc → région touristique
++_VILLE_REGION = {
++    "magog": "Cantons-de-l'Est", "orford": "Cantons-de-l'Est",
++    "eastman": "Cantons-de-l'Est", "austin": "Cantons-de-l'Est",
++    "ayer's cliff": "Cantons-de-l'Est", "ayers cliff": "Cantons-de-l'Est",
++    "north hatley": "Cantons-de-l'Est", "sherbrooke": "Cantons-de-l'Est",
++    "sainte-catherine-de-hatley": "Cantons-de-l'Est",
++    "canton d'orford": "Cantons-de-l'Est", "bromont": "Cantons-de-l'Est",
++    "sutton": "Cantons-de-l'Est", "stukely-sud": "Cantons-de-l'Est",
++    "bolton-est": "Cantons-de-l'Est", "potton": "Cantons-de-l'Est",
++    "mansonville": "Cantons-de-l'Est", "coaticook": "Cantons-de-l'Est",
++    "piopolis": "Cantons-de-l'Est", "lac-megantic": "Cantons-de-l'Est",
++}
++
++_RUE_RE = re.compile(r"^(rue|chemin|ch\.|avenue|av\.|route|rte|boulevard|"
++                     r"boul\.?|montee|impasse|allee|place)\b")
++
++
++def _num(raw: str) -> float | None:
++    try:
++        return float(raw.replace(",", "."))
++    except (TypeError, ValueError):
++        return None
++
++
++class MemoriaChalets(StConnector):
++    source_id = "memoriachalets"
++
++    # -- inventaire (sitemap FR + lastmod) -----------------------------------
++    def _sitemap_urls(self) -> dict[str, tuple[str, str]]:
++        """slug -> (url détail FR, lastmod)."""
++        xml = self.get(SITEMAP).text
++        urls: dict[str, tuple[str, str]] = {}
++        for bloc in re.findall(r"<url>(.*?)</url>", xml, re.S):
++            m = re.search(r"<loc>([^<]+)</loc>", bloc)
++            if not m:
++                continue
++            loc = m.group(1).strip()
++            mu = _URL_DETAIL.match(loc)
++            if not mu or mu.group(1) == "locations":
++                continue
++            lastmod = re.search(r"<lastmod>([^<]+)</lastmod>", bloc)
++            urls.setdefault(mu.group(1),
++                            (loc, lastmod.group(1) if lastmod else ""))
++        return urls
++
++    # -- page détail ---------------------------------------------------------
++    def _detail(self, url: str) -> dict:
++        html = self.get(url).text
++        soup = BeautifulSoup(html, "html.parser")
++        d: dict = {}
++
++        h2 = soup.select_one("h2.location-title") or soup.find("h2")
++        if h2 is not None:
++            d["title"] = re.sub(r"\s+", " ", h2.get_text(" ", strip=True))
++
++        specs = soup.select_one("p.location-specs")
++        if specs is not None:
++            m = _SPECS_RE.search(specs.get_text(" ", strip=True))
++            if m:
++                d["bedrooms"] = _num(m.group(1))
++                d["bathrooms"] = _num(m.group(2))
++                d["capacity"] = _num(m.group(3))
++
++        # « 207, Rue des Pruches, Magog, Québec, J1X 0M9, Canada »
++        adresse = soup.select_one("p.location-adress")
++        if adresse is not None:
++            texte = re.sub(r"\s+", " ", adresse.get_text(" ", strip=True))
++            d["address"] = texte
++            restants = []
++            for p in texte.split(","):
++                # code postal parfois collé à la ville (« Bromont J2L 2C1 »)
++                p = re.sub(r"\b[A-Za-z]\d[A-Za-z]\s?\d[A-Za-z]\d\b", "",
++                           p).strip()
++                k = strip_accents(p).lower()
++                if (not p or _CP_RE.match(p) or k in ("quebec", "qc", "canada")
++                        or re.match(r"^(appartement|app|unite)\b", k)):
++                    continue
++                restants.append(p)
++            if restants:
++                ville = restants[-1]
++                # adresse sans virgule (« Rue des Noyers Orford ») :
++                # la ville est le dernier mot
++                if _RUE_RE.match(strip_accents(ville).lower()):
++                    ville = ville.split()[-1]
++                d["city"] = ville
++
++        prix = soup.select_one("p.starting-price")
++        if prix is not None:
++            label = re.sub(r"\s+", " ", prix.get_text(" ", strip=True))
++            label = re.sub(r"^(À partir de\s+)+", "À partir de ", label, flags=re.I)
++            d["price_label"] = label
++
++        citq = soup.select_one("p.citq")
++        if citq is not None:
++            texte = citq.get_text(" ", strip=True)
++            m = re.search(r"CITQ\s*#?\s*(\d{6})", texte)
++            if m:
++                d["citq"] = m.group(1)
++            m = re.search(r"\(([^)]*[Ll]ocation minimum[^)]*)\)", texte)
++            if m:
++                d["location_minimum"] = m.group(1).strip()
++
++        # commodités (dont le statut animaux)
++        amen: list[str] = []
++        for span in soup.select(".accomosdations-filters li span"):
++            t = re.sub(r"\s+", " ", span.get_text(" ", strip=True))
++            if t and t not in amen:
++                amen.append(t)
++        if amen:
++            d["amenities"] = amen
++        for a in amen:
++            k = strip_accents(a).lower()
++            if "animaux" in k or "chien" in k:
++                d["pets"] = "non" if ("interdit" in k or "refus" in k
++                                      or "non admis" in k) else "oui"
++
++        # description : paragraphes de la 1re colonne de la fiche
++        col = soup.select_one('[itemprop="articleBody"] div')
++        if col is not None:
++            morceaux = []
++            for p in col.find_all("p"):
++                classes = " ".join(p.get("class") or [])
++                if any(c in classes for c in
++                       ("location-specs", "location-adress",
++                        "starting-price", "citq")):
++                    continue
++                t = p.get_text(" ", strip=True)
++                if t:
++                    morceaux.append(re.sub(r"\s+", " ", t))
++            if morceaux:
++                d["description"] = "\n".join(morceaux)[:5000]
++
++        # photos (uploads, sans logo/icônes ; dédoublonnage sur le nom de
++        # base sans suffixe de taille -WxH)
++        imgs, vus = [], set()
++        for u in re.findall(r'(https://(?:www\.)?memoriachalets\.com/'
++                            r'wp-content/uploads/[^"\'\s>]+\.(?:jpe?g|webp))',
++                            html):
++            base = re.sub(r"-\d+x\d+(?=\.\w+$)", "", u)
++            nom = strip_accents(base).lower()
++            if base in vus or "logo" in nom or "icon" in nom:
++                continue
++            vus.add(base)
++            imgs.append(re.sub(r"-\d+x\d+(?=\.\w+$)", "", u))
++        d["images"] = imgs[:20]
++        return d
++
++    # -- contrat --------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        listings: list[StListing] = []
++        for slug, (url, lastmod) in self._sitemap_urls().items():
++            try:
++                d = self.detail(slug, lastmod or "sans-lastmod",
++                                lambda u=url: self._detail(u))
++            except Exception:      # une fiche cassée ≠ inventaire perdu
++                d = {}
++            if not d.get("title"):
++                continue
++
++            hay = strip_accents(d["title"]).lower()
++            ptype = next((c for n, c in _TYPE_HINTS if n in hay), "Chalet")
++
++            # région : ville connue, sinon indice textuel (« en Estrie »…)
++            ville = d.get("city", "")
++            region = _VILLE_REGION.get(strip_accents(ville).lower(), "")
++            if not region:
++                texte = strip_accents(" ".join(
++                    (d.get("address", ""), d.get("description", "")))).lower()
++                region = next((r for n, r in _REGION_HINTS if n in texte), "")
++
++            details = {}
++            if d.get("location_minimum"):
++                details["location_minimum"] = d["location_minimum"]
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=slug,                 # slug WP, stable
++                url=url,
++                title=d["title"],
++                property_type=ptype,
++                address=d.get("address", ""),
++                city=ville,
++                region=region,
++                price_night=parse_price_night(d.get("price_label", "")),
++                price_label=d.get("price_label", ""),
++                capacity=d.get("capacity"),
++                bedrooms=d.get("bedrooms"),
++                bathrooms=d.get("bathrooms"),
++                pets=d.get("pets"),
++                citq=d.get("citq", ""),
++                description=d.get("description", ""),
++                amenities=d.get("amenities") or [],
++                details=details,
++                images=d.get("images") or [],
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/panoraloges.py : Panora Loges Fluviales (panoraloges.com) —
++#   10 loges (mini-chalets) en bord de mer à Sainte-Anne-des-Monts (Gaspésie),
++#   déclinées en DEUX gammes identiques à l'intérieur d'une même gamme :
++#   loges simples (nos 8-10, 2 pers.) et loges doubles (nos 1-7, 4 pers.).
++#
++# Méthode : site Squarespace ; l'API ?format=json de la page /fr/loges est
++#   vide (items=0) → on parse les DEUX pages de gamme statiques
++#   /fr/logessimples et /fr/logesdoubles. Chaque page expose en <h2-4> :
++#   prix (« 175 $ » sous « À partir de »), « N invités », « N chambres »,
++#   « N lits Queen », « 1 salle de bain », puis la liste des commodités
++#   jusqu'à « Stationnements ». 2 fiches « gamme » (multi_unit) plutôt que
++#   10 fiches par unité artificiellement identiques — le site lui-même
++#   laisse le libre choix de la loge à l'intérieur d'une gamme.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import re
++
++from ..schema import StListing
++from .base import StConnector
++
++SITE = "https://www.panoraloges.com"
++
++_PAGES = [
++    # (external_id, chemin, titre, unités)
++    ("loges-doubles", "/fr/logesdoubles", "Loges doubles — Panora Loges "
++     "Fluviales", "Loges 1 à 7"),
++    ("loges-simples", "/fr/logessimples", "Loges simples — Panora Loges "
++     "Fluviales", "Loges 8 à 10"),
++]
++
++_TAG_RE = re.compile(r"<[^>]+>")
++
++# images de gabarit à exclure de la galerie
++_IMG_EXCLUDE = ("favicon", "logo", "icon", "texture", "panora_ecran",
++                "Fond+de+page", "plan")
++
++
++def _text(fragment: str) -> str:
++    return _html.unescape(re.sub(r"\s+", " ", _TAG_RE.sub(" ", fragment))).strip()
++
++
++class PanoraLoges(StConnector):
++    source_id = "panoraloges"
++    request_delay = 1.0
++
++    def _parse(self, path: str) -> dict:
++        h = self.get(SITE + path).text
++        d: dict = {}
++
++        heads = [t for t in (_text(x) for x in re.findall(
++            r"(?s)<h[1-4][^>]*>(.*?)</h[1-4]>", h)) if t]
++
++        m = re.search(r"(\d+)\s*\$", " ".join(heads))
++        if m:
++            d["price_night"] = float(m.group(1))
++
++        # commodités : entêtes entre « N invités » et « Stationnements »
++        start = next((i for i, t in enumerate(heads)
++                      if re.fullmatch(r"\d+\s+invités?", t)), None)
++        end = next((i for i, t in enumerate(heads)
++                    if t.lower().startswith("stationnement")), None)
++        amen: list[str] = []
++        if start is not None and end is not None and start < end:
++            amen = heads[start:end + 1]
++        blob = " | ".join(amen)
++        for pat, key in ((r"(\d+)\s+invités?", "capacity"),
++                         (r"(\d+)\s+chambres?", "bedrooms"),
++                         (r"(\d+)\s+lits?\s+Queen", "beds"),
++                         (r"(\d+)\s+salles?\s+de\s+bain", "bathrooms")):
++            m = re.search(pat, blob, re.I)
++            if m:
++                d[key] = float(m.group(1))
++        d["amenities"] = [a for a in amen
++                          if not re.fullmatch(r"\d+\s+(invités?|chambres?"
++                                              r"|salles?\s+de\s+bain)", a)]
++
++        # description : sous-titre de gamme + infos pratiques (les <p> du
++        # gabarit Squarespace contiennent beaucoup de CSS → filtrés)
++        paras = [_text(p) for p in re.findall(r"(?s)<p[^>]*>(.*?)</p>", h)]
++        keep = [p for p in paras
++                if 60 < len(p) < 600 and "{" not in p
++                and not p.startswith(("FR:", "0 "))
++                and "Infolettre" not in p and "418-" not in p]
++        if keep:
++            d["description"] = "\n".join(keep[:6])[:3000]
++
++        imgs: list[str] = []
++        for u in re.findall(r"https://images\.squarespace-cdn\.com/[^\"\s?]+",
++                            h):
++            if any(x.lower() in u.lower() for x in _IMG_EXCLUDE):
++                continue
++            u = u.rstrip("\\,&")
++            if not re.search(r"\.(?:jpe?g|png|webp)$", u, re.I):
++                continue
++            if u not in imgs:
++                imgs.append(u)
++            if len(imgs) >= 15:
++                break
++        d["images"] = imgs
++        return d
++
++    # -- contrat --------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        listings: list[StListing] = []
++        for ext_id, path, title, units in _PAGES:
++            d = self._parse(path)
++            if not d.get("price_night") and not d.get("capacity"):
++                continue
++            price = d.get("price_night")
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=ext_id,
++                url=SITE + path,
++                title=title,
++                property_type="Chalet",
++                address="610 boul. Sainte-Anne E",
++                city="Sainte-Anne-des-Monts",
++                region="Gaspésie",
++                price_night=price,
++                price_label=f"À partir de {price:g} $ / nuit" if price else "",
++                capacity=d.get("capacity"),
++                bedrooms=d.get("bedrooms"),
++                beds=d.get("beds"),
++                bathrooms=d.get("bathrooms"),
++                description=d.get("description") or "",
++                amenities=d.get("amenities") or [],
++                details={"multi_unit": True, "units": units,
++                         "domain": "Panora Loges Fluviales"},
++                images=d.get("images") or [],
++            ))
++        return listings

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

				`@@ -16,7 +16,14 @@`
16	# description fr, capacité, photos, catégorie. On ne garde que les	16	# description fr, capacité, photos, catégorie. On ne garde que les
17	# catégories « hébergement » (table KEEP ci-dessous) ;	17	# catégories « hébergement » (table KEEP ci-dessous) ;
18	# 3. prix (cache self.detail, clé mensuelle) : POST /api/resource/feeDetails	18	# 3. prix (cache self.detail, clé mensuelle) : POST /api/resource/feeDetails
19	−# ?resourceId=…&startDate=<J+35> → feeTotal = tarif d'une nuit.	19	+# ?resourceId=…&startDate=<J+n> → feeTotal = tarif d'une nuit. Les unités
		20	+# fermées à J+35 (saisonnier) sont réessayées à J+95/185/275 ;
		21	+# 4. commodités : chaque ressource porte des definedAttributes
		22	+# (attributeDefinitionId + valeur/énums) que GET /api/attribute/filterable
		23	+# permet de traduire en libellés français (« Foyer sur l'emplacement »,
		24	+# « Chiens permis », « Éclairage fourni : solaire »…) — on ne retient que
		25	+# les attributs pertinents (table AMEN_DEFS), les dimensions techniques
		26	+# d'emplacement sont ignorées.
20	#	27	#
21	# Les ids sont des entiers négatifs (int32 min + n). Aucune géoloc par unité	28	# Les ids sont des entiers négatifs (int32 min + n). Aucune géoloc par unité
22	# dans l'API : lat/lng et région touristique viennent de la table statique	29	# dans l'API : lat/lng et région touristique viennent de la table statique
				`@@ -78,6 +85,40 @@ KEEP = {`
78		85
79	_TAG_RE = re.compile(r"<[^>]+>")	86	_TAG_RE = re.compile(r"<[^>]+>")
80		87
		88	+# Attributs « commodités » pertinents (id de définition → retenu). Les autres
		89	+# (dimensions, pentes, obstructions, ampérage…) sont du bruit technique.
		90	+AMEN_DEFS = {
		91	+ -32758, # Foyer sur l'emplacement
		92	+ -32571, # Type de foyer
		93	+ -32717, # Feux de camp permis
		94	+ -32721, # Admissible au permis de feu
		95	+ -32753, # Wi-fi
		96	+ -32754, # Couverture cellulaire
		97	+ -32760, # Barbecue fourni
		98	+ -32570, # Fourneau fourni
		99	+ -32762, # Source de chaleur interne disponible
		100	+ -32763, # Éclairage fourni
		101	+ -32764, # Électricité disponible à l'intérieur
		102	+ -32761, # Électricité disponible à l'extérieur
		103	+ -32582, # Électricité
		104	+ -32736, # Service d'eau
		105	+ -32756, # Accessible
		106	+ -32723, # Secteur riverain
		107	+ -32724, # Accès au rivage
		108	+ -32725, # Conditions de baignade
		109	+ -32757, # Tables de pique-nique
		110	+ -32748, # Ombrage à l'emplacement
		111	+ -32759, # Casiers à provisions fournis
		112	+ -32713, # Stationnement
		113	+ -32709, # Permis de pêche inclus
		114	+ -32715, # Vélos permis
		115	+}
		116	+PETS_DEFS = {-32718, -32572} # Chiens permis / Animaux de compagnie permis
		117	+MIN_STAY_DEF = -32697 # Séjour minimum (nuits)
		118	+
		119	+# valeurs d'énum « négatives » : l'attribut est alors omis des commodités
		120	+_VAL_NEGATIVES = {"non", "no", "aucun", "aucune", "none", "n/a"}
		121	+
81		122
82	def _fr(localized: list[dict], *keys: str) -> dict:	123	def _fr(localized: list[dict], *keys: str) -> dict:
83	by_culture = {v.get("cultureName"): v for v in (localized or [])}	124	by_culture = {v.get("cultureName"): v for v in (localized or [])}
				`@@ -105,17 +146,80 @@ class ParcsCanada(StConnector):`
105		146
106	# -- prix d'une nuit (cache BD, clé mensuelle) -------------------------------	147	# -- prix d'une nuit (cache BD, clé mensuelle) -------------------------------
107	def _fetch_fee(self, resource_id: int) -> dict:	148	def _fetch_fee(self, resource_id: int) -> dict:
108	− start = (datetime.date.today()	149	+ # unités saisonnières : pas de tarif hors saison → on sonde plusieurs
109	− + datetime.timedelta(days=35)).isoformat()	150	+ # dates réparties sur l'année jusqu'à trouver une nuit tarifée
110	− resp = self.post(	151	+ for jours in (35, 95, 185, 275):
111	− BASE + "/api/resource/feeDetails",	152	+ start = (datetime.date.today()
112	− params={"resourceId": resource_id, "startDate": start,	153	+ + datetime.timedelta(days=jours)).isoformat()
113	− "boatLength": 0, "bookingCategoryId": 0,	154	+ try:
114	− "entryPointResourceId": 0, "exitPointResourceId": 0},	155	+ resp = self.post(
115	− json=[], headers=HEADERS)	156	+ BASE + "/api/resource/feeDetails",
116	− fees = (resp.json() or {}).get("resourceFeeDetails") or []	157	+ params={"resourceId": resource_id, "startDate": start,
117	− total = sum(f.get("feeTotal") or 0 for f in fees)	158	+ "boatLength": 0, "bookingCategoryId": 0,
118	− return {"fee": round(total, 2)} if total > 0 else {}	159	+ "entryPointResourceId": 0,
		160	+ "exitPointResourceId": 0},
		161	+ json=[], headers=HEADERS)
		162	+ except Exception: # noqa: BLE001 — on tente la date suivante
		163	+ continue
		164	+ fees = (resp.json() or {}).get("resourceFeeDetails") or []
		165	+ total = sum(f.get("feeTotal") or 0 for f in fees)
		166	+ if total > 0:
		167	+ return {"fee": round(total, 2), "date": start}
		168	+ return {}
		169	+
		170	+ # -- définitions d'attributs (libellés fr des commodités) --------------------
		171	+ def _fetch_attr_defs(self) -> dict:
		172	+ data = self._api("/api/attribute/filterable") or {}
		173	+ defs: dict = {}
		174	+ for key, v in data.items():
		175	+ fr = _fr(v.get("localizedValues") or [])
		176	+ name = fr.get("displayName") or ""
		177	+ if not name:
		178	+ continue
		179	+ values = {}
		180	+ for ev in v.get("values") or []:
		181	+ lab = _fr(ev.get("localizedValues") or []).get("displayName")
		182	+ if lab is not None and ev.get("enumValue") is not None:
		183	+ values[str(ev["enumValue"])] = lab
		184	+ defs[str(key)] = {"name": name, "values": values}
		185	+ return defs
		186	+
		187	+ @staticmethod
		188	+ def _amenities(res: dict, defs: dict) -> tuple[list[str], str \| None,
		189	+ float \| None]:
		190	+ """(commodités, animaux oui/non, séjour minimum) d'une ressource."""
		191	+ amen: list[str] = []
		192	+ pets: str \| None = None
		193	+ min_stay: float \| None = None
		194	+ for da in res.get("definedAttributes") or []:
		195	+ did = da.get("attributeDefinitionId")
		196	+ d = defs.get(str(did))
		197	+ if did == MIN_STAY_DEF and da.get("value") is not None:
		198	+ min_stay = float(da["value"])
		199	+ continue
		200	+ if d is None:
		201	+ continue
		202	+ labels = [d["values"].get(str(v)) for v in (da.get("values") or [])]
		203	+ labels = [l for l in labels if l]
		204	+ if did in PETS_DEFS and labels:
		205	+ pets = "non" if all(
		206	+ l.lower() in _VAL_NEGATIVES for l in labels) else "oui"
		207	+ continue
		208	+ if did not in AMEN_DEFS:
		209	+ continue
		210	+ positifs = [l for l in labels
		211	+ if l.lower() not in _VAL_NEGATIVES]
		212	+ if not positifs:
		213	+ continue
		214	+ if all(l.lower() in ("oui", "yes") for l in positifs):
		215	+ item = d["name"] # booléen : le nom suffit
		216	+ else:
		217	+ item = f"{d['name']} : {', '.join(positifs)}"
		218	+ if item not in amen:
		219	+ amen.append(item)
		220	+ # l'API renvoie les attributs dans un ordre variable : trier pour
		221	+ # un diff stable dans la base
		222	+ return sorted(amen), pets, min_stay
119		223
120	# -- contrat --------------------------------------------------------------	224	# -- contrat --------------------------------------------------------------
121	def fetch(self) -> list[StListing]:	225	def fetch(self) -> list[StListing]:
				`@@ -128,6 +232,14 @@ class ParcsCanada(StConnector):`
128	cat_names[c.get("resourceCategoryId")] = name	232	cat_names[c.get("resourceCategoryId")] = name
129		233
130	month = datetime.date.today().strftime("%Y-%m") # prix revus au mois	234	month = datetime.date.today().strftime("%Y-%m") # prix revus au mois
		235	+
		236	+ # libellés fr des attributs (une requête, cache BD mensuel)
		237	+ try:
		238	+ attr_defs = self.detail("_attrdefs", month, self._fetch_attr_defs)
		239	+ except Exception as exc: # noqa: BLE001 — les commodités sont optionnelles
		240	+ print(f"[parcscanada] définitions d'attributs : {exc}",
		241	+ file=sys.stderr)
		242	+ attr_defs = {}
131	listings: list[StListing] = []	243	listings: list[StListing] = []
132	for loc_id, (loc_name, region, lat, lng) in QC_LOCATIONS.items():	244	for loc_id, (loc_name, region, lat, lng) in QC_LOCATIONS.items():
133	try:	245	try:
				`@@ -162,13 +274,20 @@ class ParcsCanada(StConnector):`
162	title = f"{cat_fr} {name} – {loc_name}"	274	title = f"{cat_fr} {name} – {loc_name}"
163		275
164	try:	276	try:
165	− fee = self.detail(str(rid), month,	277	+ # « v2 » : sondage multi-dates (unités saisonnières)
		278	+ fee = self.detail(str(rid), month + ":v2",
166	lambda r=rid: self._fetch_fee(r))	279	lambda r=rid: self._fetch_fee(r))
167	except Exception as exc: # noqa: BLE001 — le prix est optionnel	280	except Exception as exc: # noqa: BLE001 — le prix est optionnel
168	print(f"[parcscanada] tarif {rid} : {exc}", file=sys.stderr)	281	print(f"[parcscanada] tarif {rid} : {exc}", file=sys.stderr)
169	fee = {}	282	fee = {}
170	price = fee.get("fee")	283	price = fee.get("fee")
171		284
		285	+ amenities, pets_attr, min_stay = self._amenities(
		286	+ res, attr_defs)
		287	+ details = {"parc": loc_name, "categorie": cat_fr}
		288	+ if min_stay:
		289	+ details["sejour_minimum"] = min_stay
		290	+
172	cap = res.get("maxCapacity")	291	cap = res.get("maxCapacity")
173	listings.append(StListing(	292	listings.append(StListing(
174	source=self.source_id,	293	source=self.source_id,
				`@@ -182,9 +301,10 @@ class ParcsCanada(StConnector):`
182	price_night=float(price) if price else None,	301	price_night=float(price) if price else None,
183	price_label=(f"{price:.2f} $ / nuit" if price else ""),	302	price_label=(f"{price:.2f} $ / nuit" if price else ""),
184	capacity=float(cap) if cap else None,	303	capacity=float(cap) if cap else None,
185	− pets=_pets(desc),	304	+ pets=pets_attr or _pets(desc),
186	description=desc[:4000],	305	description=desc[:4000],
187	− details={"parc": loc_name, "categorie": cat_fr},	306	+ amenities=amenities,
		307	+ details=details,
188	images=images,	308	images=images,
189	lat=lat,	309	lat=lat,
190	lng=lng,	310	lng=lng,

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/pourvoiries.py : Fédération des pourvoiries du Québec
++# (pourvoiries.com) — ~340 pourvoiries avec hébergement (chalets, camps,
++# pavillons, prêt-à-camper) partout en région.
++#
++# Méthode (TYPO3, aucun anti-bot) :
++#   1. sitemap officiel des établissements (/sitemap/outfitters/sitemap.xml)
++#      → inventaire complet des fiches /pourvoiries/<slug>-<zone>-<permis> ;
++#   2. fiche établissement (cache self.detail, clé mensuelle) : nom, ville +
++#      région (bandeau), description, coordonnées GPS (« Latitude : 48.805 »),
++#      no d'établissement CITQ, période d'ouverture, type de restauration,
++#      unités d'hébergement de l'onglet Hébergements (Pavillon / Chalet /
++#      Camp / Prêt-à-camper… avec capacité et chambres), photos du carrousel ;
++#   3. prix : les fiches n'affichent pas de tarif d'hébergement ; le sitemap
++#      des forfaits (/sitemap/packages/sitemap.xml, slug préfixé du no de
++#      permis) donne un prix « par personne / nuit » pour ~80 pourvoiries →
++#      price_label du forfait le plus bas (à défaut d'un vrai prix/nuit).
++#
++# Une annonce = un établissement (les unités individuelles ne sont pas
++# réservables en ligne — la liste des unités va dans details["unites"]).
++# Seules les fiches avec au moins une unité d'hébergement sont retenues.
++# Réglage env : LOUKA_POURVOIRIES_LIMIT (nb max de fiches, 0 = tout).
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import os
++import re
++import sys
++import time
++
++from ..schema import StListing, normalize_region
++from .base import StConnector
++
++BASE = "https://www.pourvoiries.com"
++SITEMAP_FICHES = f"{BASE}/sitemap/outfitters/sitemap.xml"
++SITEMAP_FORFAITS = f"{BASE}/sitemap/packages/sitemap.xml"
++PREFIX_FICHE = f"{BASE}/pourvoiries/"
++PREFIX_FORFAIT = f"{BASE}/forfaits/"
++
++_LOC_RE = re.compile(r"<loc>\s*(https?://[^<\s]+)")
++_PERMIS_RE = re.compile(r"(\d{2}-\d{3})$")           # fin du slug établissement
++_FORFAIT_PERMIS_RE = re.compile(r"^(\d{2}-\d{3})-")  # début du slug forfait
++_LAT_RE = re.compile(r"Latitude\s*:\s*(-?\d+\.\d+)")
++_LNG_RE = re.compile(r"Longitude\s*:\s*(-?\d+\.\d+)")
++_CAP_RE = re.compile(r"Pour\s+(\d+)\s+personne", re.I)
++_CH_RE = re.compile(r"(\d+)\s+chambre", re.I)
++_PRIX_FORFAIT_RE = re.compile(
++    r'<strong class="price">\s*([\d\s,.  ]+)\s*\$', re.S)
++
++# Régions FPQ → région touristique canonique (le reste passe par
++# normalize_region : Mauricie, Outaouais, Côte-Nord…)
++_REGIONS_FPQ = {
++    "gaspésie et îles-de-la-madeleine": "Gaspésie",
++    "gaspesie et iles-de-la-madeleine": "Gaspésie",
++    "saguenay-lac-saint-jean": "Saguenay–Lac-Saint-Jean",
++    "nord-du-québec": "Nord-du-Québec",
++    "baie-james": "Eeyou Istchee Baie-James",
++}
++
++# Titre de section d'hébergement → type canonique Lou-Ka
++_TYPE_UNITE = {
++    "chalet": "Chalet", "pavillon": "Auberge", "auberge": "Auberge",
++    "camp": "Refuge", "refuge": "Refuge", "yourte": "Yourte",
++    "dôme": "Dôme", "tente": "Prêt-à-camper",
++    "prêt-à-camper": "Prêt-à-camper", "camping": "Camping",
++    "chambre": "Chambre", "maison": "Maison", "condo": "Condo",
++}
++
++
++def _property_type(types_unites: list[str]) -> str:
++    """Type dominant de l'établissement — le chalet prime (offre principale)."""
++    canon = [_TYPE_UNITE.get(t.strip().lower(), "") for t in types_unites]
++    for pref in ("Chalet", "Auberge", "Yourte", "Dôme", "Prêt-à-camper",
++                 "Refuge", "Maison", "Condo", "Chambre", "Camping"):
++        if pref in canon:
++            return pref
++    return "Chalet"
++
++
++class Pourvoiries(StConnector):
++    source_id = "pourvoiries"
++    request_delay = 0.8
++
++    # -- fiche établissement --------------------------------------------------
++    def _fetch_fiche(self, slug: str) -> dict:
++        from bs4 import BeautifulSoup
++        html = self.get(PREFIX_FICHE + slug).text
++        soup = BeautifulSoup(html, "html.parser")
++        d: dict = {}
++
++        h1 = soup.select_one("h1.page-title")
++        if not h1:
++            return {}
++        d["nom"] = h1.get_text(" ", strip=True)
++
++        # bandeau : « Rivière-Bonjour, Gaspésie et Îles-de-la-Madeleine »
++        banner = soup.select_one(".banner-single .region")
++        if banner:
++            loc = banner.get_text(" ", strip=True)
++            ville, _, region = loc.partition(", ")
++            d["ville"], d["region"] = ville.strip(), region.strip()
++
++        # description (premier bloc sous le h2 « Description »)
++        for h2 in soup.find_all("h2"):
++            if h2.get_text(strip=True).lower() == "description":
++                paras = [p.get_text(" ", strip=True)
++                         for p in h2.find_all_next("p", limit=4)]
++                d["description"] = "\n".join(x for x in paras if x)[:2500]
++                break
++
++        # onglet Informations : paires h3 → p
++        infos: dict[str, str] = {}
++        for h3 in soup.find_all("h3"):
++            p = h3.find_next_sibling("p")
++            if p is not None:
++                infos[h3.get_text(" ", strip=True).lower()] = \
++                    p.get_text(" ", strip=True)
++        for label, key in (("numéro d'établissement", "citq"),
++                           ("période d'ouverture", "ouverture"),
++                           ("type de restauration", "restauration"),
++                           ("type de pourvoirie", "type_pourvoirie"),
++                           ("langue de service", "langues")):
++            for k, v in infos.items():
++                if k.startswith(label):
++                    d[key] = v
++                    break
++
++        m = _LAT_RE.search(html)
++        if m:
++            d["lat"] = float(m.group(1))
++        m = _LNG_RE.search(html)
++        if m:
++            d["lng"] = float(m.group(1))
++
++        # onglet Hébergements : sections (h2.block-title) → cartes d'unités
++        unites: list[dict] = []
++        heb = soup.find(id="hebergements")
++        if heb is not None:
++            for bloc in heb.select(".block-slides"):
++                t = bloc.select_one("h2.block-title")
++                type_u = t.get_text(" ", strip=True) if t else ""
++                for card in bloc.select(".card"):
++                    titre = card.select_one(".card-title")
++                    if titre is None:
++                        continue
++                    txt = card.get_text(" ", strip=True)
++                    cap = _CAP_RE.search(txt)
++                    ch = _CH_RE.search(txt)
++                    unites.append({
++                        "type": type_u,
++                        "nom": titre.get_text(" ", strip=True),
++                        "capacite": int(cap.group(1)) if cap else None,
++                        "chambres": int(ch.group(1)) if ch else None,
++                        "etoiles": len(card.select(".card-icons-stars "
++                                                   ".icon-star")) or None,
++                    })
++        d["unites"] = unites
++
++        # photos du carrousel principal
++        imgs: list[str] = []
++        slider = soup.select_one(".block-slider-img")
++        if slider is not None:
++            for img in slider.find_all("img"):
++                u = img.get("data-src") or img.get("src") or ""
++                if u.startswith("/"):
++                    u = BASE + u
++                if u.startswith("https://") and u not in imgs:
++                    imgs.append(u)
++        d["images"] = imgs[:12]
++        return d
++
++    # -- page forfait (prix « par personne / nuit ») ---------------------------
++    def _fetch_forfait(self, slug: str) -> dict:
++        html = self.get(PREFIX_FORFAIT + slug).text
++        m = _PRIX_FORFAIT_RE.search(html)
++        if not m:
++            return {}
++        try:
++            prix = float(re.sub(r"[\s  ]", "", m.group(1)).replace(",", "."))
++        except ValueError:
++            return {}
++        unite = ""
++        mm = re.search(r'class="card-pricing">.*?<p>([^<]+)</p>', html, re.S)
++        if mm:
++            unite = mm.group(1).strip()
++        return {"prix": prix, "unite": unite}
++
++    # -- inventaire ------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        limit = int(os.environ.get("LOUKA_POURVOIRIES_LIMIT", "0") or 0)
++        month = time.strftime("%Y-%m")      # re-visite mensuelle des fiches
++
++        xml = self.get(SITEMAP_FICHES).text
++        slugs = sorted({loc[len(PREFIX_FICHE):].strip("/")
++                        for loc in _LOC_RE.findall(xml)
++                        if loc.startswith(PREFIX_FICHE)})
++
++        # forfaits groupés par no de permis (slug « 01-501-… »)
++        forfaits: dict[str, list[str]] = {}
++        try:
++            xmlf = self.get(SITEMAP_FORFAITS).text
++            for loc in _LOC_RE.findall(xmlf):
++                if not loc.startswith(PREFIX_FORFAIT):
++                    continue
++                fslug = loc[len(PREFIX_FORFAIT):].strip("/")
++                m = _FORFAIT_PERMIS_RE.match(fslug)
++                if m:
++                    forfaits.setdefault(m.group(1), []).append(fslug)
++        except Exception as exc:  # noqa: BLE001 — les forfaits sont optionnels
++            print(f"[pourvoiries] sitemap forfaits : {exc}", file=sys.stderr)
++
++        listings: list[StListing] = []
++        for slug in slugs:
++            try:
++                d = self.detail(slug, month, lambda s=slug: self._fetch_fiche(s))
++            except Exception as exc:  # noqa: BLE001
++                print(f"[pourvoiries] fiche {slug} : {exc}", file=sys.stderr)
++                continue
++            unites = d.get("unites") or []
++            if not d.get("nom") or not unites:   # pas d'hébergement → hors sujet
++                continue
++
++            # prix : forfait le moins cher de la pourvoirie (par pers. / nuit)
++            price_label = ""
++            m = _PERMIS_RE.search(slug)
++            permis = m.group(1) if m else ""
++            best: dict = {}
++            for fslug in forfaits.get(permis, []):
++                try:
++                    f = self.detail(f"forfait:{fslug}", month,
++                                    lambda s=fslug: self._fetch_forfait(s))
++                except Exception as exc:  # noqa: BLE001
++                    print(f"[pourvoiries] forfait {fslug} : {exc}",
++                          file=sys.stderr)
++                    continue
++                # seuls les forfaits tarifés à la nuit (ou au jour) sont
++                # comparables — un prix « par personne / séjour » fausserait
++                # le prix/nuit dérivé par finalize(). Attention : « séjour »
++                # contient « jour », d'où l'exclusion explicite.
++                unite = f.get("unite", "").lower()
++                if "jour" not in unite and "nuit" not in unite:
++                    continue
++                if "séjour" in unite or "sejour" in unite:
++                    continue
++                if f.get("prix") and (not best or f["prix"] < best["prix"]):
++                    best = f
++            if best:
++                unite = best.get("unite") or "par personne / nuit"
++                price_label = (f"forfait à partir de {best['prix']:.0f} $ "
++                               f"{unite}")
++
++            region = d.get("region", "")
++            region = _REGIONS_FPQ.get(region.lower(), normalize_region(region))
++
++            caps = [u["capacite"] for u in unites if u.get("capacite")]
++            chs = [u["chambres"] for u in unites if u.get("chambres")]
++            details = {k: v for k, v in {
++                "permis": permis,
++                "nb_unites": len(unites),
++                "unites": unites[:40],
++                "ouverture": d.get("ouverture", ""),
++                "restauration": d.get("restauration", ""),
++                "type_pourvoirie": d.get("type_pourvoirie", ""),
++                "langues": d.get("langues", ""),
++            }.items() if v}
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=slug,
++                url=PREFIX_FICHE + slug,
++                title=d["nom"],
++                property_type=_property_type([u["type"] for u in unites]),
++                city=d.get("ville", ""),
++                region=region,
++                price_label=price_label,
++                capacity=float(max(caps)) if caps else None,
++                bedrooms=float(max(chs)) if chs else None,
++                citq=d.get("citq", ""),
++                description=d.get("description", ""),
++                details=details,
++                images=d.get("images") or [],
++                lat=d.get("lat"),
++                lng=d.get("lng"),
++            ))
++            if limit and len(listings) >= limit:
++                break
++        return listings

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

				`@@ -7,10 +7,18 @@`
7	# Méthode : pagination de la liste globale /chalets-a-louer?page=N (site	7	# Méthode : pagination de la liste globale /chalets-a-louer?page=N (site
8	# ASP.NET WebForms, 12 cartes/page, HTML statique — la pagination « infinie »	8	# ASP.NET WebForms, 12 cartes/page, HTML statique — la pagination « infinie »
9	# accepte le paramètre ?page). Cartes : id stable (/chalet-a-louer/<id>),	9	# accepte le paramètre ?page). Cartes : id stable (/chalet-a-louer/<id>),
10	−# titre, région + ville, capacité, chambres, photo. La page détail (via	10	+# titre, région + ville, capacité, chambres, photo, et souvent un prix
11	−# self.detail, cache BD) en variante ?map=o ajoute lat/lng (champs cachés	11	+# « à partir de » (encadré .ListPrix : « Nuit 395$ » ou « Semaine 1030$ »).
12	−# InfoLocalisation_hf_lat/long — absents de la page de base), grille de	12	+# La page détail (via self.detail, cache BD) en variante ?map=o ajoute
13	−# tarifs, description, no CITQ, sdb/lits, commodités et photos.	13	+# lat/lng (champs cachés InfoLocalisation_hf_lat/long — absents de la page
		14	+# de base), grille de tarifs, description, no CITQ, sdb/lits, commodités
		15	+# et photos.
		16	+#
		17	+# Prix : ~40 % des fiches seulement ont la grille de tarifs ; les autres ont
		18	+# soit un tarif en texte libre (ctl16_lblvchTarif_Terme, parfois avec
		19	+# montants — attention aux dépôts), soit rien du tout (contact direct).
		20	+# Ordre de préférence : grille détail > texte libre détail > encadré de la
		21	+# carte liste. Beaucoup de fiches n'affichent réellement aucun prix.
14	# -----------------------------------------------------------------------------	22	# -----------------------------------------------------------------------------
15	from __future__ import annotations	23	from __future__ import annotations
16		24
				`@@ -88,10 +96,11 @@ class QuebecLocationDeChalets(StConnector):`
88	page += 1	96	page += 1
89		97
90	for lst in listings:	98	for lst in listings:
		99	+ # « v2 » : tarif en texte libre ajouté au parseur détail
91	cle = hashlib.sha1(("\|".join([	100	cle = hashlib.sha1(("\|".join([
92	lst.title, lst.city, lst.region,	101	lst.title, lst.city, lst.region,
93	str(lst.capacity), str(lst.bedrooms),	102	str(lst.capacity), str(lst.bedrooms),
94	− ]) + time.strftime("\|%Y-%m")).encode("utf-8")).hexdigest()	103	+ ]) + time.strftime("\|%Y-%m\|v2")).encode("utf-8")).hexdigest()
95	try:	104	try:
96	d = self.detail(lst.external_id, cle,	105	d = self.detail(lst.external_id, cle,
97	lambda u=lst.url: self._detail(u))	106	lambda u=lst.url: self._detail(u))
				`@@ -99,8 +108,12 @@ class QuebecLocationDeChalets(StConnector):`
99	d = {}	108	d = {}
100	if not d:	109	if not d:
101	continue	110	continue
102	− lst.price_night = d.get("price_night")	111	+ # le prix de la page détail prime ; sinon on garde celui de la
103	− lst.price_label = d.get("price_label") or ""	112	+ # carte de liste (« à partir de … »)
		113	+ if d.get("price_night") is not None:
		114	+ lst.price_night = d["price_night"]
		115	+ if d.get("price_label"):
		116	+ lst.price_label = d["price_label"]
104	lst.description = d.get("description") or ""	117	lst.description = d.get("description") or ""
105	lst.citq = d.get("citq") or ""	118	lst.citq = d.get("citq") or ""
106	lst.amenities = d.get("amenities") or []	119	lst.amenities = d.get("amenities") or []
				`@@ -159,6 +172,16 @@ class QuebecLocationDeChalets(StConnector):`
159	if img is not None:	172	if img is not None:
160	images.append(urljoin(BASE, img["src"].split("?")[0]))	173	images.append(urljoin(BASE, img["src"].split("?")[0]))
161		174
		175	+ # encadré de prix de la carte (« à partir de / Nuit 395$ » ou
		176	+ # « Semaine 1030$ ») — repli si la page détail n'affiche aucun tarif.
		177	+ # NE PAS remonter plus haut que la carte : on attraperait le prix
		178	+ # d'une carte voisine.
		179	+ prix_label, prix_nuit = "", None
		180	+ bloc = carte.select_one(".ListPrix") if carte is not None else None
		181	+ if bloc is not None:
		182	+ prix_label = re.sub(r"\s+", " ", bloc.get_text(" ", strip=True))
		183	+ prix_nuit = _prix_nuit(prix_label, prix_label)
		184	+
162	return StListing(	185	return StListing(
163	source=self.source_id,	186	source=self.source_id,
164	external_id=eid,	187	external_id=eid,
				`@@ -167,6 +190,8 @@ class QuebecLocationDeChalets(StConnector):`
167	property_type="Chalet",	190	property_type="Chalet",
168	city=ville,	191	city=ville,
169	region=_REGIONS.get(region, region),	192	region=_REGIONS.get(region, region),
		193	+ price_night=prix_nuit,
		194	+ price_label=prix_label,
170	capacity=capacite,	195	capacity=capacite,
171	bedrooms=chambres,	196	bedrooms=chambres,
172	images=images,	197	images=images,
				`@@ -238,6 +263,28 @@ class QuebecLocationDeChalets(StConnector):`
238	d["price_night"] = _prix_nuit(d["price_label"],	263	d["price_night"] = _prix_nuit(d["price_label"],
239	d["price_label"])	264	d["price_label"])
240		265
		266	+ # tarif en texte libre (fiches sans grille) : on ne retient que les
		267	+ # phrases avec un montant ET une période (nuit/jour/semaine), en
		268	+ # ignorant dépôts et cautions
		269	+ if "price_night" not in d:
		270	+ terme = soup.find(id="ctl16_lblvchTarif_Terme")
		271	+ if terme is not None:
		272	+ candidats = []
		273	+ # split en phrases sans casser les décimales (« 129.00$ »)
		274	+ for phrase in re.split(r"[\n;•]\|\.(?!\d)",
		275	+ terme.get_text("\n", strip=True)):
		276	+ if "$" not in phrase \
		277	+ or re.search(r"(?i)d[ée]p[ôo]t\|caution\|rabais", phrase) \
		278	+ or not re.search(r"(?i)nuit\|jour\|sem", phrase):
		279	+ continue
		280	+ pn = _prix_nuit(phrase, phrase)
		281	+ if pn:
		282	+ candidats.append((pn, phrase.strip()))
		283	+ if candidats:
		284	+ pn, phrase = min(candidats)
		285	+ d["price_night"] = pn
		286	+ d.setdefault("price_label", re.sub(r"\s+", " ", phrase)[:120])
		287	+
241	desc = soup.find(id="InfoDescription_pnlDescription")	288	desc = soup.find(id="InfoDescription_pnlDescription")
242	if desc is not None:	289	if desc is not None:
243	texte = desc.get_text("\n", strip=True)	290	texte = desc.get_text("\n", strip=True)

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/rezerve.py : Rëzerve / reserver.ca (Charlevoix, Laurentides,
++# Estrie, Lanaudière, Mauricie, Outaouais…)
++#
++# Gestionnaire québécois (~85 chalets) sur moteur Guesty. Le site reserver.ca
++# est un Next.js (App Router) : le catalogue /chalets est RENDU SERVEUR et le
++# payload React Flight (`self.__next_f.push([1,"…"])`) contient l'objet
++# {"listings":[…]} complet — id Guesty, slug, nom, description fr, photos,
++# chambres, sdb, lits, capacité, prix « à partir de » CAD, ville, adresse,
++# lat/lng, commodités, numéro CITQ, heures d'arrivée/départ. UNE SEULE requête
++# suffit, aucune page détail à visiter.
++#   External_id = id Guesty (stable). URL publique : /chalets/<slug>.
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import json
++import re
++
++from ..schema import StListing
++from .base import StConnector
++
++SITE = "https://reserver.ca"
++
++
++def _num(v) -> float | None:
++    try:
++        return float(v) if v not in (None, "") else None
++    except (TypeError, ValueError):
++        return None
++
++
++def _flight_blob(html: str) -> str:
++    """Reconstitue le payload React Flight (chunks __next_f concaténés)."""
++    parts = []
++    for c in re.findall(r'self\.__next_f\.push\(\[1,"((?:[^"\\]|\\.)*)"\]\)',
++                        html):
++        try:
++            parts.append(json.loads(f'"{c}"'))
++        except ValueError:
++            continue
++    return "".join(parts)
++
++
++class Rezerve(StConnector):
++    source_id = "rezerve"
++
++    def _catalog(self) -> list[dict]:
++        html = self.get(f"{SITE}/chalets").text
++        blob = _flight_blob(html)
++        i = blob.find('{"listings":[')
++        if i < 0:
++            return []
++        obj, _ = json.JSONDecoder().raw_decode(blob[i:])
++        return obj.get("listings") or []
++
++    @staticmethod
++    def _description(it: dict) -> str:
++        desc = str(it.get("description") or "")
++        if not desc or desc.startswith("$"):     # référence Flight non résolue
++            desc = str((it.get("descriptions") or {}).get("fr") or "")
++        if desc.startswith("$"):
++            desc = ""
++        return re.sub(r"\s+", " ", desc).strip()[:4000]
++
++    # -- contrat ----------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        listings: list[StListing] = []
++        for it in self._catalog():
++            lid = str(it.get("id") or "").strip()
++            slug = (it.get("slug") or "").strip()
++            title = (it.get("name") or "").strip()
++            if not lid or not slug or not title:
++                continue
++
++            geo = it.get("geo") or {}
++            citq = str((it.get("citq") or {}).get("number") or "").strip()
++            street = (it.get("addressStreet") or "").strip()
++            postal = (it.get("addressPostal") or "").strip()
++            price = _num(it.get("priceFromCAD"))
++
++            details = {k: v for k, v in {
++                "guesty_id": lid,
++                "area_sqft": it.get("areaSquareFeet"),
++                "check_in": it.get("checkInTime"),
++                "check_out": it.get("checkOutTime"),
++                "tags": it.get("tags") or None,
++            }.items() if v}
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=lid,
++                url=f"{SITE}/chalets/{slug}",
++                title=title,
++                property_type="Chalet",
++                address=" ".join(p for p in (street, postal) if p),
++                city=(it.get("city") or "").strip(),
++                region="",                # ville + lat/lng font foi
++                price_night=price,
++                price_label=(f"à partir de {price:.0f} $ / nuit"
++                             if price else ""),
++                capacity=_num(it.get("maxGuests")),
++                bedrooms=_num(it.get("bedrooms")),
++                beds=_num(it.get("beds")),
++                bathrooms=_num(it.get("bathrooms")),
++                citq=citq if re.fullmatch(r"\d{6}", citq) else "",
++                description=self._description(it),
++                amenities=[a for a in (it.get("amenities") or [])
++                           if isinstance(a, str)][:80],
++                details=details,
++                images=[u for u in (it.get("images") or [])
++                        if isinstance(u, str)][:20],
++                lat=_num(geo.get("lat")),
++                lng=_num(geo.get("lng")),
++            ))
++        return listings

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

++# -----------------------------------------------------------------------------
++# Lou-Ka — Location court terme
++# connectors/rvmt.py : Rendez-vous Mont-Tremblant (rvmt.com) — agence de
++#   gestion locative de la station Mont-Tremblant, ~108 condos, maisons et
++#   maisons de ville (Plateau, Algonquin, Étoile du Matin, etc.).
++#
++# Méthode : le site (Nuxt 3) renvoie systématiquement 429 en direct →
++#   UN SEUL appel Scrapfly (sans render_js) sur une page de complexe
++#   (/fr/algonquin — la page liste n'embarque PAS les taxonomies, la page
++#   complexe si). Tout l'inventaire (les 108 unités) vit dans le
++#   <script id="__NUXT_DATA__"> au format devalue : un tableau plat où les
++#   valeurs des dicts/listes sont des INDEX entiers vers d'autres cases
++#   (wrappers ["ShallowReactive", n] à déréférencer).
++#   On y trouve :
++#     - le nœud racine {units-rvmt: [108 unités], features-rvmt, beds-rvmt,
++#       rooms-rvmt, areas-rvmt, amenities-rvmt} — chaque unité est complète :
++#       code (external_id stable, ex. PLA214-03), adresse+lat/lng, chambres,
++#       sdb, occupancy, pets_allowed, rental_license (CITQ), min/max_price
++#       ($/nuit CAD), description fr, galerie Cloudinary, features/amenities
++#       (ids → libellés fr via les taxonomies), lits par pièce ;
++#     - le nœud site-config {pages, nav, slug} dont les pages
++#       data == {"id": <mongo-id du complexe>} donnent l'URL du complexe →
++#       URL détail = /fr/<complexe>/<slug(nom)> (2 unités non mappées
++#       retombent sur la page liste).
++#
++# Réglage env : LOUKA_RVMT_LIMIT (nb max d'annonces, 0 = tout).
++# -----------------------------------------------------------------------------
++from __future__ import annotations
++
++import html as _html
++import json
++import os
++import re
++import unicodedata
++
++from ..schema import StListing
++from .base import StConnector
++
++LIST_URL = "https://www.rvmt.com/fr/condos-mont-tremblant"
++PAYLOAD_URL = "https://www.rvmt.com/fr/algonquin"  # payload complet (taxos)
++
++# tag pt-* → type canonique
++_TYPES = {"pt-condo": "Condo", "pt-townhome": "Maison",
++          "pt-private-home": "Maison", "pt-hotel": "Condo"}
++
++_WRAPPERS = ("ShallowReactive", "Reactive", "Ref", "ShallowRef", "EmptyRef",
++             "EmptyShallowRef")
++
++
++def _slugify(name: str) -> str:
++    s = unicodedata.normalize("NFKD", name).encode("ascii", "ignore").decode()
++    return re.sub(r"-{2,}", "-", re.sub(r"[^a-z0-9]+", "-", s.lower())).strip("-")
++
++
++def _fr(node) -> str:
++    """Nœud {text: {fr, en}} ou {fr, en} → libellé français (repli anglais)."""
++    if isinstance(node, dict):
++        t = node.get("text") if isinstance(node.get("text"), dict) else node
++        if isinstance(t, dict):
++            return _html.unescape(str(t.get("fr") or t.get("en") or "")).strip()
++    return ""
++
++
++class Rvmt(StConnector):
++    source_id = "rvmt"
++
++    # -- devalue --------------------------------------------------------------
++    def _resolve(self, arr: list, i, seen: frozenset = frozenset()):
++        v = arr[i] if isinstance(i, int) and 0 <= i < len(arr) else i
++        if isinstance(v, dict):
++            if i in seen:
++                return None
++            return {k: self._resolve(arr, x, seen | {i}) for k, x in v.items()}
++        if isinstance(v, list):
++            if v and v[0] in _WRAPPERS:
++                return self._resolve(arr, v[1], seen) if len(v) > 1 else None
++            if i in seen:
++                return None
++            return [self._resolve(arr, x, seen | {i}) for x in v]
++        return v
++
++    # -- contrat --------------------------------------------------------------
++    def fetch(self) -> list[StListing]:
++        limit = int(os.environ.get("LOUKA_RVMT_LIMIT", "0") or 0)
++        h = self.get_scrapfly(PAYLOAD_URL, render_js=False)
++        m = re.search(r'(?s)<script[^>]*id="__NUXT_DATA__"[^>]*>(.*?)</script>',
++                      h)
++        if not m:
++            return []
++        arr = json.loads(m.group(1))
++
++        # racine = le dict qui contient unités ET taxonomies (une page liste
++        # n'aurait que units-rvmt : on garde le nœud le plus complet)
++        root = None
++        site_cfg = None
++        fallback_i = None
++        for i, v in enumerate(arr):
++            if not isinstance(v, dict):
++                continue
++            if root is None and "units-rvmt" in v:
++                if "features-rvmt" in v:
++                    root = self._resolve(arr, i)
++                elif fallback_i is None:
++                    fallback_i = i
++            elif site_cfg is None and {"pages", "nav", "slug"} <= set(v):
++                site_cfg = self._resolve(arr, i)
++            if root is not None and site_cfg is not None:
++                break
++        if root is None and fallback_i is not None:
++            root = self._resolve(arr, fallback_i)
++        if not root:
++            return []
++
++        units = root.get("units-rvmt") or []
++        tax = {name: {t.get("value"): _fr(t)
++                      for t in (root.get(f"{name}-rvmt") or [])
++                      if isinstance(t, dict)}
++               for name in ("features", "beds", "rooms", "areas", "amenities")}
++
++        # id de complexe → slug d'URL (pages du site-config avec data={id})
++        complexes: dict[str, str] = {}
++        for p in (site_cfg or {}).get("pages") or []:
++            data = p.get("data") if isinstance(p, dict) else None
++            if isinstance(data, dict) and set(data) == {"id"} and p.get("url"):
++                complexes[str(data["id"])] = str(p["url"]).strip("/")
++
++        listings: list[StListing] = []
++        vus: set[str] = set()
++        for u in units:
++            if not isinstance(u, dict):
++                continue
++            code = str(u.get("code") or "").strip()
++            name = _html.unescape(str(u.get("name") or "")).strip()
++            if not code or code in vus or not name:
++                continue
++            vus.add(code)
++
++            comp = complexes.get(str(u.get("complex") or ""))
++            url = (f"https://www.rvmt.com/fr/{comp}/{_slugify(name)}"
++                   if comp else LIST_URL)
++
++            addr = u.get("address") or {}
++            tags = u.get("tags") or []
++            ptype = next((_TYPES[t] for t in tags if t in _TYPES), "Condo")
++            area = tax["areas"].get(u.get("area")) or ""
++
++            # lits : somme des quantités des pièces déclarées
++            beds = 0
++            for room in u.get("rooms") or []:
++                for b in (room or {}).get("beds") or []:
++                    try:
++                        beds += int(b.get("quantity") or 0)
++                    except (TypeError, ValueError):
++                        pass
++
++            amen: list[str] = []
++            for f in u.get("features") or []:
++                t = tax["features"].get(f)
++                if t and t not in amen:
++                    amen.append(t)
++            for a in u.get("amenities") or []:
++                t = tax["amenities"].get((a or {}).get("amenity"))
++                if t and t not in amen:
++                    amen.append(t)
++
++            desc = u.get("short_description") or {}
++            description = _html.unescape(str(desc.get("fr")
++                                             or desc.get("en") or "")).strip()
++
++            price = u.get("min_price")
++            price = float(price) if isinstance(price, (int, float)) \
++                and 20 <= price <= 20000 else None
++            price_label = f"À partir de {price:g} $ / nuit" if price else ""
++
++            gallery = [g for g in (u.get("gallery") or [])
++                       if isinstance(g, str) and g.startswith("https://")]
++
++            details = {k: v for k, v in {
++                "area": area,
++                "complex": comp or "",
++                "max_price_night": u.get("max_price"),
++                "wheelchair_accessible": bool(u.get("wheelchair_accessible")),
++            }.items() if v}
++
++            line1 = str(addr.get("line_1") or "").strip()
++            apt = str(addr.get("apt") or "").strip()
++
++            listings.append(StListing(
++                source=self.source_id,
++                external_id=code,
++                url=url,
++                title=name,
++                property_type=ptype,
++                address=f"{line1}, app. {apt}" if line1 and apt else line1,
++                city=str(addr.get("city") or "Mont-Tremblant").strip(),
++                region="Laurentides",
++                price_night=price,
++                price_label=price_label,
++                capacity=float(u["occupancy"]) if u.get("occupancy") else None,
++                bedrooms=float(u["bedrooms"]) if u.get("bedrooms") is not None
++                         else None,
++                beds=float(beds) if beds else None,
++                bathrooms=float(u["bathrooms"]) if u.get("bathrooms") else None,
++                pets="oui" if u.get("pets_allowed") else "non",
++                citq=str(u.get("rental_license") or "").strip(),
++                description=description[:5000],
++                amenities=amen,
++                details=details,
++                images=gallery[:20],
++                lat=addr.get("latitude"),
++                lng=addr.get("longitude"),
++            ))
++            if limit and len(listings) >= limit:
++                break
++        return listings

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

				`@@ -23,6 +23,14 @@`
23	# distinctif dans le sitemap (il faudrait crawler chaque boucle de camping).	23	# distinctif dans le sitemap (il faudrait crawler chaque boucle de camping).
24	# Région touristique déduite de l'établissement (table statique ci-dessous).	24	# Région touristique déduite de l'établissement (table statique ci-dessous).
25	# Le site est derrière Cloudflare : self.get() escalade automatiquement.	25	# Le site est derrière Cloudflare : self.get() escalade automatiquement.
		26	+#
		27	+# Description : les pages unité n'ont AUCUN texte descriptif (que des listes
		28	+# d'équipements) — la prose vit sur la page éditoriale de l'établissement
		29	+# (sepaq.com/<code>/, ex. pq/mot) : on la récupère une fois par établissement
		30	+# (cache self.detail) et on l'applique aux unités. Géolocalisation : l'API
		31	+# carte échoue souvent (cookie de session perdu derrière l'anti-bot) — repli
		32	+# sur les coordonnées statiques de l'établissement (fait géographique stable,
		33	+# précision « parc » signalée dans details.geo_precision).
26	# -----------------------------------------------------------------------------	34	# -----------------------------------------------------------------------------
27	from __future__ import annotations	35	from __future__ import annotations
28		36
				`@@ -77,6 +85,85 @@ REGION_ETAB = {`
77	"auberge-de-montagne-des-chic-chocs": "Gaspésie",	85	"auberge-de-montagne-des-chic-chocs": "Gaspésie",
78	}	86	}
79		87
		88	+# Coordonnées approximatives de chaque établissement (accueil/centre du
		89	+# territoire — fait géographique stable). Repli quand l'API carte ne donne
		90	+# pas les coordonnées précises de l'unité.
		91	+ETAB_COORDS = {
		92	+ "centre-touristique-du-lac-kenogami": (48.336, -71.433),
		93	+ "centre-touristique-du-lac-simon": (46.008, -75.092),
		94	+ "parc-national-d-aiguebelle": (48.494, -78.712),
		95	+ "parc-national-d-oka": (45.472, -74.023),
		96	+ "parc-national-de-frontenac": (45.940, -71.150),
		97	+ "parc-national-de-la-gaspesie": (48.982, -66.242),
		98	+ "parc-national-de-la-jacques-cartier": (47.174, -71.374),
		99	+ "parc-national-de-la-pointe-taillon": (48.665, -72.080),
		100	+ "parc-national-de-la-yamaska": (45.462, -72.632),
		101	+ "parc-national-de-plaisance": (45.590, -75.070),
		102	+ "parc-national-des-grands-jardins": (47.667, -70.628),
		103	+ "parc-national-des-hautes-gorges-de-la-riviere-malbaie": (47.899, -70.412),
		104	+ "parc-national-des-monts-valin": (48.597, -70.828),
		105	+ "parc-national-du-bic": (48.336, -68.802),
		106	+ "parc-national-du-fjord-du-saguenay": (48.311, -70.324),
		107	+ "parc-national-du-mont-megantic": (45.455, -71.152),
		108	+ "parc-national-du-mont-orford": (45.357, -72.235),
		109	+ "parc-national-du-mont-tremblant": (46.356, -74.462),
		110	+ "reserve-faunique-ashuapmushuan": (48.890, -72.870),
		111	+ "reserve-faunique-de-matane": (48.632, -67.114),
		112	+ "reserve-faunique-de-papineau-labelle": (46.150, -75.300),
		113	+ "reserve-faunique-de-port-cartier-sept-iles": (50.318, -67.083),
		114	+ "reserve-faunique-de-port-daniel": (48.240, -64.970),
		115	+ "reserve-faunique-de-portneuf": (47.100, -72.250),
		116	+ "reserve-faunique-de-rimouski": (48.075, -68.375),
		117	+ "reserve-faunique-des-chic-chocs": (48.732, -66.463),
		118	+ "reserve-faunique-des-laurentides": (47.567, -71.233),
		119	+ "reserve-faunique-du-saint-maurice": (46.900, -73.100),
		120	+ "reserve-faunique-la-verendrye": (47.348, -76.868),
		121	+ "reserve-faunique-mastigouche": (46.600, -73.400),
		122	+ "reserve-faunique-rouge-matawin": (46.723, -74.500),
		123	+ "sepaq-anticosti": (49.500, -63.300),
		124	+ "station-touristique-duchesnay": (46.878, -71.635),
		125	+ "auberge-de-montagne-des-chic-chocs": (48.900, -66.489),
		126	+}
		127	+
		128	+# Page éditoriale de chaque établissement (sepaq.com/<code>/) — codes vérifiés
		129	+# via les titres des sitemaps etablissement/parc-national/reserve-faunique.
		130	+ETAB_EDITO = {
		131	+ "centre-touristique-du-lac-kenogami": "ct/ken",
		132	+ "centre-touristique-du-lac-simon": "ct/sim",
		133	+ "parc-national-d-aiguebelle": "pq/aig",
		134	+ "parc-national-d-oka": "pq/oka",
		135	+ "parc-national-de-frontenac": "pq/fro",
		136	+ "parc-national-de-la-gaspesie": "pq/gas",
		137	+ "parc-national-de-la-jacques-cartier": "pq/jac",
		138	+ "parc-national-de-la-pointe-taillon": "pq/pta",
		139	+ "parc-national-de-la-yamaska": "pq/yam",
		140	+ "parc-national-de-plaisance": "pq/pla",
		141	+ "parc-national-des-grands-jardins": "pq/grj",
		142	+ "parc-national-des-hautes-gorges-de-la-riviere-malbaie": "pq/hgo",
		143	+ "parc-national-des-monts-valin": "pq/mva",
		144	+ "parc-national-du-bic": "pq/bic",
		145	+ "parc-national-du-fjord-du-saguenay": "pq/sag",
		146	+ "parc-national-du-mont-megantic": "pq/mme",
		147	+ "parc-national-du-mont-orford": "pq/mor",
		148	+ "parc-national-du-mont-tremblant": "pq/mot",
		149	+ "reserve-faunique-ashuapmushuan": "rf/ash",
		150	+ "reserve-faunique-de-matane": "rf/mat",
		151	+ "reserve-faunique-de-papineau-labelle": "rf/pal",
		152	+ "reserve-faunique-de-port-cartier-sept-iles": "rf/spc",
		153	+ "reserve-faunique-de-port-daniel": "rf/pod",
		154	+ "reserve-faunique-de-portneuf": "rf/por",
		155	+ "reserve-faunique-de-rimouski": "rf/rim",
		156	+ "reserve-faunique-des-chic-chocs": "rf/chc",
		157	+ "reserve-faunique-des-laurentides": "rf/lau",
		158	+ "reserve-faunique-du-saint-maurice": "rf/stm",
		159	+ "reserve-faunique-la-verendrye": "rf/lvy",
		160	+ "reserve-faunique-mastigouche": "rf/mas",
		161	+ "reserve-faunique-rouge-matawin": "rf/rom",
		162	+ "sepaq-anticosti": "sepaq-anticosti",
		163	+ "station-touristique-duchesnay": "ct/duc",
		164	+ "auberge-de-montagne-des-chic-chocs": "ct/amc",
		165	+}
		166	+
80	_LOC_RE = re.compile(r"<loc>\s*(https?://[^<\s]+)")	167	_LOC_RE = re.compile(r"<loc>\s*(https?://[^<\s]+)")
81	_COOKIE_RE = re.compile(r"(?:JSESSIONID_TRANSAC\|__cf_bm)=[^;,\s]+")	168	_COOKIE_RE = re.compile(r"(?:JSESSIONID_TRANSAC\|__cf_bm)=[^;,\s]+")
82	_JSON_ARRAY_RE = re.compile(r"\[.*\]", re.S)	169	_JSON_ARRAY_RE = re.compile(r"\[.*\]", re.S)
				`@@ -171,6 +258,34 @@ class Sepaq(StConnector):`
171	})	258	})
172	return {"items": items}	259	return {"items": items}
173		260
		261	+ # -- page éditoriale d'un établissement (description riche) -----------------
		262	+ _EDITO_BRUIT = ("témoins", "cookies", "javascript", "modalités de réserv",
		263	+ "navigateur", "abonnez-vous", "infolettre")
		264	+
		265	+ def _fetch_edito(self, code: str) -> dict:
		266	+ from bs4 import BeautifulSoup
		267	+ html = self.get(f"{BASE}/{code}/").text
		268	+ soup = BeautifulSoup(html, "html.parser")
		269	+ if soup.title and "404" in soup.title.get_text():
		270	+ return {}
		271	+ parts: list[str] = []
		272	+ for p in soup.find_all("p"):
		273	+ txt = re.sub(r"\s+", " ", p.get_text(" ", strip=True))
		274	+ low = txt.lower()
		275	+ if len(txt) < 120 or any(b in low for b in self._EDITO_BRUIT):
		276	+ continue
		277	+ if txt not in parts:
		278	+ parts.append(txt)
		279	+ if sum(len(x) for x in parts) > 1200:
		280	+ break
		281	+ desc = "\n\n".join(parts)
		282	+ if not desc: # repli : meta description de la page
		283	+ m = re.search(r'<meta name="description" content="([^"]+)"', html)
		284	+ if m:
		285	+ import html as _h
		286	+ desc = _h.unescape(m.group(1)).strip()
		287	+ return {"description": desc[:2000]} if desc else {}
		288	+
174	# -- page détail d'une unité --------------------------------------------------	289	# -- page détail d'une unité --------------------------------------------------
175	def _fetch_unit(self, slug: str) -> dict:	290	def _fetch_unit(self, slug: str) -> dict:
176	from bs4 import BeautifulSoup	291	from bs4 import BeautifulSoup
				`@@ -287,6 +402,21 @@ class Sepaq(StConnector):`
287	if path:	402	if path:
288	geo[path] = it	403	geo[path] = it
289		404
		405	+ # description éditoriale par établissement (une visite, cache BD)
		406	+ editos: dict[str, str] = {}
		407	+ for etab in etabs:
		408	+ code = ETAB_EDITO.get(etab)
		409	+ if not code:
		410	+ continue
		411	+ try:
		412	+ payload = self.detail(f"edito:{etab}", "v1",
		413	+ lambda cd=code: self._fetch_edito(cd))
		414	+ except Exception as exc: # noqa: BLE001 — la description est optionnelle
		415	+ print(f"[sepaq] édito {etab} : {exc}", file=sys.stderr)
		416	+ continue
		417	+ if payload.get("description"):
		418	+ editos[etab] = payload["description"]
		419	+
290	month = time.strftime("%Y-%m") # re-visite mensuelle (prix/saison)	420	month = time.strftime("%Y-%m") # re-visite mensuelle (prix/saison)
291	listings: list[StListing] = []	421	listings: list[StListing] = []
292	for slug in sorted(set(units) \| set(geo)):	422	for slug in sorted(set(units) \| set(geo)):
				`@@ -322,6 +452,14 @@ class Sepaq(StConnector):`
322		452
323	amenities = (d.get("sections") or {}).get("Description") or []	453	amenities = (d.get("sections") or {}).get("Description") or []
324		454
		455	+ # géo : coordonnées précises de l'unité (API carte) sinon repli
		456	+ # sur celles de l'établissement (précision « parc »)
		457	+ lat, lng = g.get("lat"), g.get("lng")
		458	+ if lat is None or lng is None:
		459	+ lat, lng = ETAB_COORDS.get(etab, (None, None))
		460	+ if lat is not None:
		461	+ details["geo_precision"] = "etablissement"
		462	+
325	lst = StListing(	463	lst = StListing(
326	source=self.source_id,	464	source=self.source_id,
327	external_id=slug,	465	external_id=slug,
				`@@ -339,11 +477,12 @@ class Sepaq(StConnector):`
339	beds=float(d["beds"]) if d.get("beds") else None,	477	beds=float(d["beds"]) if d.get("beds") else None,
340	pets=d.get("pets"),	478	pets=d.get("pets"),
341	citq=d.get("citq", ""),	479	citq=d.get("citq", ""),
		480	+ description=editos.get(etab, ""),
342	amenities=amenities,	481	amenities=amenities,
343	details=details,	482	details=details,
344	images=d.get("images") or [],	483	images=d.get("images") or [],
345	− lat=g.get("lat"),	484	+ lat=lat,
346	− lng=g.get("lng"),	485	+ lng=lng,
347	)	486	)
348	listings.append(lst)	487	listings.append(lst)
349	return listings	488	return listings

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

				`@@ -17,6 +17,10 @@`
17	# (self.__next_f.push) : description, commodités, capacité.	17	# (self.__next_f.push) : description, commodités, capacité.
18	# 3. AUCUN PRIX PUBLIC : le tarif est négocié entre l'hôte et l'assureur	18	# 3. AUCUN PRIX PUBLIC : le tarif est négocié entre l'hôte et l'assureur
19	# (« couvert par l'assurance ») → price_night=None, prix absent assumé.	19	# (« couvert par l'assurance ») → price_night=None, prix absent assumé.
		20	+# Vérifié 2026-08-25 : ni l'index Algolia, ni le flux React Flight, ni
		21	+# le document Firestore public (projects/sinistar-13fdf …/housings/<id>,
		22	+# lisible sans auth) ne contiennent de champ prix ou note — les montants
		23	+# circulent uniquement dans les soumissions hôte↔assureur (auth requise).
20	# La région touristique est déduite des coordonnées (centroïdes Airbnb).	24	# La région touristique est déduite des coordonnées (centroïdes Airbnb).
21	#	25	#
22	# Réglage env : LOUKA_SINISTAR_LIMIT (nb max d'annonces, 0 = tout ; utile	26	# Réglage env : LOUKA_SINISTAR_LIMIT (nb max d'annonces, 0 = tout ; utile

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

				`@@ -10,22 +10,31 @@`
10	# salles de bain, capacité, note/avis, adresse, lat/lng, photos (galerie	10	# salles de bain, capacité, note/avis, adresse, lat/lng, photos (galerie
11	# streamlinevrs.com). La description longue vient du bloc	11	# streamlinevrs.com). La description longue vient du bloc
12	# <div class="description block">, les commodités des <li class="amenity_item">.	12	# <div class="description block">, les commodités des <li class="amenity_item">.
13	−# Pas de prix statique : les tarifs passent par l'API Streamline	13	+# PRIX : pas de prix statique dans le HTML, mais l'API Streamline passe par
14	−# (admin-ajax.php), bloquée par Cloudflare en POST — price_night reste vide.	14	+# admin-ajax.php avec action=streamlinecore-api-request et le corps JSON
		15	+# {methodName, params} DANS LA QUERY STRING (format du plugin Angular) —
		16	+# contrairement au POST classique, ce format n'est pas bloqué par
		17	+# Cloudflare. GetPropertyRatesRawData(unit_id) retourne la grille des
		18	+# tarifs saisonniers ($/nuit) → price_night = minimum des périodes
		19	+# courantes/futures (« à partir de »). Rafraîchi à chaque run (37 appels).
15	# Les /monthly-rentals/ (units-sitemap.xml) sont du long terme : ignorés.	20	# Les /monthly-rentals/ (units-sitemap.xml) sont du long terme : ignorés.
16	# -----------------------------------------------------------------------------	21	# -----------------------------------------------------------------------------
17	from __future__ import annotations	22	from __future__ import annotations
18		23
		24	+import datetime as _dt
19	import html as _html	25	import html as _html
20	import json	26	import json
21	import os	27	import os
22	import re	28	import re
		29	+import sys
		30	+from urllib.parse import urlencode
23		31
24	from ..schema import StListing	32	from ..schema import StListing
25	from .base import StConnector	33	from .base import StConnector
26		34
27	SITE = "https://www.tremblantliving.ca"	35	SITE = "https://www.tremblantliving.ca"
28	SITEMAP = SITE + "/property-sitemap.xml"	36	SITEMAP = SITE + "/property-sitemap.xml"
		37	+AJAX = SITE + "/wp-admin/admin-ajax.php"
29		38
30	# type déduit du nom de la fiche (agence ~100 % chalets et condos)	39	# type déduit du nom de la fiche (agence ~100 % chalets et condos)
31	_TYPE_HINTS = [	40	_TYPE_HINTS = [
				`@@ -53,6 +62,45 @@ def _f(v) -> float \| None:`
53	class TremblantLiving(StConnector):	62	class TremblantLiving(StConnector):
54	source_id = "tremblant_living"	63	source_id = "tremblant_living"
55		64
		65	+ # -- API Streamline (via admin-ajax, JSON en query string) ----------------
		66	+ def _api(self, method: str, params: dict) -> dict:
		67	+ req = json.dumps({"methodName": method, "params": params},
		68	+ separators=(",", ":"))
		69	+ q = urlencode({"action": "streamlinecore-api-request", "params": req})
		70	+ resp = self.post(f"{AJAX}?{q}",
		71	+ headers={"Content-Type": "application/json"})
		72	+ return resp.json()
		73	+
		74	+ def _price_from_rates(self, unit_id: str) -> tuple[float \| None, str]:
		75	+ """Prix « à partir de » = minimum $/nuit des périodes tarifaires
		76	+ courantes et futures (GetPropertyRatesRawData). Jamais mis en cache :
		77	+ les tarifs saisonniers bougent sans que la page change."""
		78	+ data = self._api("GetPropertyRatesRawData",
		79	+ {"unit_id": int(unit_id)}).get("data") or {}
		80	+ rates = data.get("rates") or []
		81	+ today = _dt.date.today()
		82	+ prices: list[float] = []
		83	+ for r in rates if isinstance(rates, list) else [rates]:
		84	+ try:
		85	+ end = _dt.datetime.strptime(
		86	+ str(r.get("period_end") or ""), "%m/%d/%Y").date()
		87	+ except ValueError:
		88	+ end = today # période sans date : on la garde
		89	+ if end < today:
		90	+ continue # saison passée
		91	+ for k in ("daily_first_interval_price",
		92	+ "daily_second_interval_price"):
		93	+ m = re.search(r"(\d[\d,]*(?:\.\d+)?)", str(r.get(k) or ""))
		94	+ if m:
		95	+ v = float(m.group(1).replace(",", ""))
		96	+ if 20 <= v <= 20000:
		97	+ prices.append(v)
		98	+ if not prices:
		99	+ return None, ""
		100	+ mn = min(prices)
		101	+ mn = int(mn) if mn == int(mn) else mn
		102	+ return float(mn), f"à partir de {mn} $ / nuit"
		103	+
56	# -- page détail --------------------------------------------------------	104	# -- page détail --------------------------------------------------------
57	def _detail(self, url: str) -> dict:	105	def _detail(self, url: str) -> dict:
58	h = self.get(url).text	106	h = self.get(url).text
				`@@ -134,6 +182,17 @@ class TremblantLiving(StConnector):`
134	if isinstance(imgs, str):	182	if isinstance(imgs, str):
135	imgs = [imgs]	183	imgs = [imgs]
136	reviews = agg.get("reviewCount")	184	reviews = agg.get("reviewCount")
		185	+
		186	+ # tarif « à partir de » via l'API Streamline (hors cache détail)
		187	+ price_night, price_label = None, ""
		188	+ unit_id = str(ld.get("identifier") or "")
		189	+ if unit_id.isdigit():
		190	+ try:
		191	+ price_night, price_label = self._price_from_rates(unit_id)
		192	+ except Exception as exc: # tarif manquant ≠ annonce perdue
		193	+ print(f"[tremblant_living] tarifs {unit_id} : {exc}",
		194	+ file=sys.stderr)
		195	+
137	listings.append(StListing(	196	listings.append(StListing(
138	source=self.source_id,	197	source=self.source_id,
139	external_id=str(ld.get("identifier") or slug),	198	external_id=str(ld.get("identifier") or slug),
				`@@ -143,6 +202,8 @@ class TremblantLiving(StConnector):`
143	address=_text(str(addr.get("streetAddress") or "")),	202	address=_text(str(addr.get("streetAddress") or "")),
144	city=_text(str(addr.get("addressLocality") or "Mont-Tremblant")),	203	city=_text(str(addr.get("addressLocality") or "Mont-Tremblant")),
145	region="Laurentides",	204	region="Laurentides",
		205	+ price_night=price_night,
		206	+ price_label=price_label,
146	capacity=_f(occupancy),	207	capacity=_f(occupancy),
147	bedrooms=_f(place.get("numberOfBedrooms")),	208	bedrooms=_f(place.get("numberOfBedrooms")),
148	bathrooms=_f(place.get("numberOfBathroomsTotal")),	209	bathrooms=_f(place.get("numberOfBathroomsTotal")),

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

				`@@ -10,13 +10,21 @@`
10	#	10	#
11	# Limites assumées : ~18 cartes rendues par destination (liste virtualisée,	11	# Limites assumées : ~18 cartes rendues par destination (liste virtualisée,
12	# le scroll ne persiste pas plus de cartes dans le snapshot DOM), pas de	12	# le scroll ne persiste pas plus de cartes dans le snapshot DOM), pas de
13	−# lat/lng ni d'adresse sur les cartes (géocodage aval possible), images	13	+# lat/lng ni d'adresse sur les cartes, images présentes seulement sur les
14	−# présentes seulement sur les cartes proches du viewport initial.	14	+# cartes proches du viewport initial.
15	# Recherche SANS dates : Vrbo affiche alors un prix « à partir de » par nuit	15	# Recherche SANS dates : Vrbo affiche alors un prix « à partir de » par nuit
16	# sur les prochaines dates disponibles → price_label + price_night plancher.	16	# sur les prochaines dates disponibles → price_label + price_night plancher.
		17	+#
		18	+# Enrichissement : la page détail (Scrapfly ASP SANS rendu JS — le SSR suffit)
		19	+# porte description, commodités, capacité, lat/lng et ~6 photos (voir
		20	+# _expediadetail.py). ⚠️ certains slugs ont un suffixe (p1234567vb) : l'URL
		21	+# sans suffixe redirige vers une page région — on conserve le slug complet.
		22	+# Réglage env : LOUKA_VRBO_DETAIL_LIMIT (fetchs détail par sync, défaut 100 ;
		23	+# cache permanent dans louka_ct.db, le parc se complète au fil des syncs).
17	# -----------------------------------------------------------------------------	24	# -----------------------------------------------------------------------------
18	from __future__ import annotations	25	from __future__ import annotations
19		26
		27	+import os
20	import re	28	import re
21	import sys	29	import sys
22	from urllib.parse import quote	30	from urllib.parse import quote
				`@@ -24,8 +32,13 @@ from urllib.parse import quote`
24	from bs4 import BeautifulSoup	32	from bs4 import BeautifulSoup
25		33
26	from ..schema import StListing	34	from ..schema import StListing
		35	+from . import _expediadetail as _ed
27	from .base import StConnector	36	from .base import StConnector
28		37
		38	+
		39	+class _DetailSkip(Exception):
		40	+ """Fiche détail sautée (budget épuisé / page invalide) — pas de cache."""
		41	+
29	# (destination Vrbo, ville affichée, région touristique QC)	42	# (destination Vrbo, ville affichée, région touristique QC)
30	DESTINATIONS = [	43	DESTINATIONS = [
31	("Mont-Tremblant, Québec, Canada", "Mont-Tremblant", "Laurentides"),	44	("Mont-Tremblant, Québec, Canada", "Mont-Tremblant", "Laurentides"),
				`@@ -61,7 +74,8 @@ TYPE_MAP = {`
61	"hébergement": "Autre",	74	"hébergement": "Autre",
62	}	75	}
63		76
64	−_ID_RE = re.compile(r"/location/p(\d+)")	77	+# slug complet (p123vb) ET id numérique — le suffixe est requis dans l'URL
		78	+_ID_RE = re.compile(r"/location/(p(\d+)[a-z]{0,2})")
65	_TYPELINE_RE = re.compile(	79	_TYPELINE_RE = re.compile(
66	r"^([A-ZÀ-Ý][\w’' -]{2,30})\s*·", re.UNICODE)	80	r"^([A-ZÀ-Ý][\w’' -]{2,30})\s*·", re.UNICODE)
67	_BEDROOMS_RE = re.compile(r"(\d+)\s*chambres?")	81	_BEDROOMS_RE = re.compile(r"(\d+)\s*chambres?")
				`@@ -84,8 +98,8 @@ class Vrbo(StConnector):`
84	m = _ID_RE.search(href)	98	m = _ID_RE.search(href)
85	if not m:	99	if not m:
86	return None	100	return None
87	− external_id = m.group(1)	101	+ external_id = m.group(2)
88	− url = f"https://www.vrbo.com/fr-ca/location/p{external_id}"	102	+ url = f"https://www.vrbo.com/fr-ca/location/{m.group(1)}"
89		103
90	title = ""	104	title = ""
91	for h in card.find_all("h3"):	105	for h in card.find_all("h3"):
				`@@ -164,6 +178,39 @@ class Vrbo(StConnector):`
164	images=images,	178	images=images,
165	)	179	)
166		180
		181	+ # -- enrichissement par la page détail ---------------------------------------
		182	+ def _enrich_details(self, listings: list[StListing]) -> None:
		183	+ """Visite les fiches détail via le cache self.detail() sous budget :
		184	+ les hits de cache sont gratuits, seuls les fetchs réseau comptent."""
		185	+ limit = max(0, int(os.environ.get("LOUKA_VRBO_DETAIL_LIMIT", "100")
		186	+ or 100))
		187	+ used = enriched = streak = 0
		188	+ for lst in listings:
		189	+ def fetch_fn(url=lst.url):
		190	+ nonlocal used, streak
		191	+ if used >= limit or streak >= 5: # tempête anti-bot : on coupe
		192	+ raise _DetailSkip
		193	+ used += 1
		194	+ html = self.get_scrapfly(url, render_js=False, asp=True)
		195	+ payload = _ed.parse_detail(html)
		196	+ if not payload:
		197	+ streak += 1
		198	+ raise _DetailSkip # blocage/vide : pas de cache
		199	+ streak = 0
		200	+ return payload
		201	+
		202	+ try:
		203	+ d = self.detail(lst.external_id, "v1", fetch_fn)
		204	+ except _DetailSkip:
		205	+ continue
		206	+ except Exception: # noqa: BLE001 — une fiche ne bloque pas le run
		207	+ continue
		208	+ if d:
		209	+ _ed.apply_detail(lst, d)
		210	+ enriched += 1
		211	+ print(f"[vrbo] détail : {enriched} annonces enrichies"
		212	+ f" ({used}/{limit} fetchs réseau)", file=sys.stderr)
		213	+
167	# -- contrat -----------------------------------------------------------------	214	# -- contrat -----------------------------------------------------------------
168	def fetch(self) -> list[StListing]:	215	def fetch(self) -> list[StListing]:
169	listings: dict[str, StListing] = {}	216	listings: dict[str, StListing] = {}
				`@@ -188,4 +235,6 @@ class Vrbo(StConnector):`
188	continue	235	continue
189	if lst and lst.external_id not in listings:	236	if lst and lst.external_id not in listings:
190	listings[lst.external_id] = lst	237	listings[lst.external_id] = lst
191	− return list(listings.values())	238	+ out = list(listings.values())
		239	+ self._enrich_details(out)
		240	+ return out

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

+ from __future__ import annotations
+ import json
++import math
+ import threading
+ from pathlib import Path
+     return {"sources": registry}
++def _percentile(sorted_vals: list[float], q: float) -> float:
++    if not sorted_vals:
++        return 0.0
++    pos = (len(sorted_vals) - 1) * q
++    lo, hi = int(pos), min(int(pos) + 1, len(sorted_vals) - 1)
++    return sorted_vals[lo] + (sorted_vals[hi] - sorted_vals[lo]) * (pos - lo)
++
++
++def _haversine_km(lat1, lng1, lat2, lng2) -> float:
++    rl1, rl2 = math.radians(lat1), math.radians(lat2)
++    dlat, dlng = rl2 - rl1, math.radians(lng2 - lng1)
++    a = (math.sin(dlat / 2) ** 2
++         + math.cos(rl1) * math.cos(rl2) * math.sin(dlng / 2) ** 2)
++    return 6371.0 * 2 * math.asin(math.sqrt(a))
++
++
++@router.get("/listings/{uid}/context")
++def ct_listing_context(uid: str):
++    """Contexte d'une fiche : analyse du prix/nuit vs segment comparable
++    (région → + type → + capacité) et hébergements similaires à proximité."""
++    con = db.connect()
++    row = con.execute("SELECT * FROM st_listings WHERE uid=?",
++                      (uid,)).fetchone()
++    if row is None:
++        con.close()
++        raise HTTPException(404, "Hébergement introuvable")
++    l = dict(row)
++
++    # --- analyse de prix : segment le plus précis avec ≥ 12 comparables ------
++    price_block = None
++    if l["price_night"] is not None and l["region"]:
++        candidates: list[tuple[str, str, list]] = []
++        base_sql = (" AND region=?")
++        base_args: list = [l["region"]]
++        if l["property_type"] and l["capacity"]:
++            candidates.append((
++                f"{l['property_type']} · {int(l['capacity'])}±2 pers. · {l['region']}",
++                base_sql + " AND property_type=? AND capacity BETWEEN ? AND ?",
++                base_args + [l["property_type"], l["capacity"] - 2,
++                             l["capacity"] + 2]))
++        if l["property_type"]:
++            candidates.append((
++                f"{l['property_type']} · {l['region']}",
++                base_sql + " AND property_type=?",
++                base_args + [l["property_type"]]))
++        candidates.append((l["region"], base_sql, base_args))
++
++        for label, extra, args in candidates:
++            vals = [r["p"] for r in con.execute(
++                "SELECT price_night p FROM st_listings WHERE active=1"
++                " AND price_night IS NOT NULL AND uid<>?" + extra
++                + " ORDER BY price_night", [uid] + args)]
++            if len(vals) < 12:
++                continue
++            med = _percentile(vals, 0.5)
++            deviation = (l["price_night"] - med) / med if med else None
++            verdict = None
++            if deviation is not None:
++                verdict = ("sous" if deviation <= -0.15
++                           else "dans" if deviation < 0.12 else "dessus")
++            # histogramme 12 classes entre p5 et p95 (queues écrasées)
++            lo, hi = _percentile(vals, 0.05), _percentile(vals, 0.95)
++            bins = []
++            if hi > lo:
++                step = (hi - lo) / 12
++                edges = [lo + i * step for i in range(13)]
++                counts = [0] * 12
++                for v in vals:
++                    i = min(11, max(0, int((v - lo) / step)))
++                    counts[i] += 1
++                bins = [{"x0": round(edges[i]), "x1": round(edges[i + 1]),
++                         "n": counts[i]} for i in range(12)]
++            rank = sum(1 for v in vals if v <= l["price_night"])
++            price_block = {
++                "segment": label, "n": len(vals),
++                "median": round(med), "p25": round(_percentile(vals, 0.25)),
++                "p75": round(_percentile(vals, 0.75)),
++                "deviation": round(deviation, 3) if deviation is not None else None,
++                "verdict": verdict,
++                "percentile": round(100 * rank / len(vals)),
++                "histogram": bins,
++            }
++            break
++
++    # --- hébergements similaires ---------------------------------------------
++    similar: list[dict] = []
++    if l["lat"] is not None and l["lng"] is not None:
++        dlat = 0.45   # ≈ 50 km
++        dlng = dlat / max(0.2, math.cos(math.radians(l["lat"])))
++        rows = con.execute(
++            "SELECT * FROM st_listings WHERE active=1 AND uid<>?"
++            " AND lat BETWEEN ? AND ? AND lng BETWEEN ? AND ?"
++            " AND images IS NOT NULL AND images<>'[]' LIMIT 400",
++            (uid, l["lat"] - dlat, l["lat"] + dlat,
++             l["lng"] - dlng, l["lng"] + dlng)).fetchall()
++        scored = []
++        for r in rows:
++            km = _haversine_km(l["lat"], l["lng"], r["lat"], r["lng"])
++            if km > 50:
++                continue
++            same_type = (l["property_type"]
++                         and r["property_type"] == l["property_type"])
++            scored.append((0 if same_type else 1, km, r))
++        scored.sort(key=lambda t: (t[0], t[1]))
++        for _, km, r in scored[:8]:
++            d = _row_to_dict(r)
++            d["distance_km"] = round(km, 1)
++            similar.append(d)
++    if not similar and l["region"]:
++        sql = ("SELECT * FROM st_listings WHERE active=1 AND uid<>?"
++               " AND region=? AND images IS NOT NULL AND images<>'[]'")
++        args = [uid, l["region"]]
++        if l["property_type"]:
++            sql += " AND property_type=?"
++            args.append(l["property_type"])
++        sql += " ORDER BY rating IS NULL, rating DESC, first_seen DESC LIMIT 8"
++        similar = [_row_to_dict(r) for r in con.execute(sql, args)]
++
++    con.close()
++    return {"price": price_block, "similar": similar}
++
++
+ @router.get("/listings/{uid}")
+ def ct_listing(uid: str):
+     con = db.connect()

spb/lou-ka

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

Theme