SPB Git
spboucher.ai

spb/lou-ka

Public

Lou·Ka — tous les logements à louer du Québec, un seul endroit.

www.lou-ka.com
webappreal-estatequebecrental

Expansion P2 — Estrie (15 connecteurs, +279 annonces)

Famille Houzez factorisée (dynamic -> gestimmo_estrie, agence_sherbrooke) ·
uptimo (51) · dynamic (49) · matinale (42, Crawl-Delay 20 respecté) ·
gestimmo (41) · montagnais (6 campus étudiants) · floria (Livya) + 8 autres.
6 non-connectables documentés (plateforme plogg morte, vitrines sans prix).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Simon-Pierre Boucher committed (Aug 9, 2026) parent 25b2275 Browse files

58 changed files +20,001 −0

58 changed files
Load all 58 files Unified Split
added louka/connectors/agence_sherbrooke.py +34 −0
@@ -0,0 +1,34 @@
1 +# -----------------------------------------------------------------------------
2 +# Lou-Ka — Agrégateur de logements à louer (province de Québec)
3 +# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
4 +# connectors/agence_sherbrooke.py : connecteur Agence de location Sherbrooke
5 +# (agencedelocationsherbrooke.com) — le portail d'annonces du groupe
6 +# Prestiplex (prestiplex.com n'affiche plus d'inventaire : son sitemap
7 +# property ne contient qu'une fiche de test). Sherbrooke, East Angus, Magog.
8 +# Même plateforme WordPress + thème Houzez que Gestion Dynamic : parsing
9 +# hérité de DynamicConnector. Particularités du site :
10 +# - la PAGE D'ACCUEIL est la page d'annonces (LIST_PATH = "/") ;
11 +# - la disponibilité est l'étiquette /label/ de la carte
12 +# (« Libre maintenant », « Juillet »…) ;
13 +# - l'adresse complète (Nominatim) est déjà sur la carte
14 +# (address.item-address) — ville/secteur en sont déduits.
15 +# -----------------------------------------------------------------------------
16 +from __future__ import annotations
17 +
18 +from .dynamic import DynamicConnector
19 +
20 +
21 +class AgenceSherbrookeConnector(DynamicConnector):
22 + source_id = "agence_sherbrooke"
23 +
24 + BASE = "https://agencedelocationsherbrooke.com"
25 + LIST_PATH = "/"
26 + CITY_DEFAULT = "Sherbrooke"
27 + max_pages = 6
28 +
29 + # -- crochets par site --------------------------------------------------------
30 + def _card_availability(self, card, title: str) -> str:
31 + """Agence : étiquette /label/ de la carte (« Libre maintenant »,
32 + « Juillet »…) — le lien /status/ porte plutôt le secteur."""
33 + label_el = card.select_one("a[href*='/label/']")
34 + return label_el.get_text(" ", strip=True) if label_el else ""
added louka/connectors/alouer_sherbrooke.py +178 −0
@@ -0,0 +1,178 @@
1 +# -----------------------------------------------------------------------------
2 +# Lou-Ka — Agrégateur de logements à louer (province de Québec)
3 +# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
4 +# connectors/alouer_sherbrooke.py : connecteur À Louer Sherbrooke
5 +# (alouersherbrooke.com) — 100+ logements dans 5 immeubles regroupés du
6 +# quartier Université (Sherbrooke) ; clientèle étudiants/professionnels/
7 +# retraités. WordPress (thème idconception) : la liste est servie par
8 +# admin-ajax `pagination-load-posts` (CPT appartements, 8 cartes/page,
9 +# pagination dans la réponse). Cartes : classe `dispo` (À louer, avec date
10 +# « À partir du … ») ou `loue` (Loué — exclues), grandeur (3½…), quartier,
11 +# inclusions et photo. Les fiches (via self.detail, cache BD) ajoutent la
12 +# description complète et la galerie. AUCUN prix ni adresse civique publiés
13 +# par la source (immeubles regroupés, quartier Université) — champs laissés
14 +# vides, rien d'inventé. external_id = slug du billet.
15 +# -----------------------------------------------------------------------------
16 +from __future__ import annotations
17 +
18 +import hashlib
19 +import re
20 +
21 +from bs4 import BeautifulSoup
22 +
23 +from ..schema import Listing, normalize_unit_type
24 +from .base import BaseConnector
25 +
26 +BASE = "https://www.alouersherbrooke.com"
27 +AJAX_URL = f"{BASE}/wp-admin/admin-ajax.php"
28 +
29 +_VARIANT_IMG = re.compile(r"-\d{2,4}x\d{2,4}(?=\.(?:jpg|jpeg|png|webp)$)", re.I)
30 +
31 +
32 +class AlouerSherbrookeConnector(BaseConnector):
33 + source_id = "alouer_sherbrooke"
34 + request_delay = 0.6
35 + max_pages = 12 # garde-fou (7 pages observées)
36 + max_details = 30 # garde-fou fiches détail (vraies requêtes)
37 +
38 + def _ajax_page(self, page: int) -> BeautifulSoup:
39 + resp = self.session.post(
40 + AJAX_URL,
41 + data={"page": str(page), "action": "pagination-load-posts"},
42 + timeout=self.timeout)
43 + resp.raise_for_status()
44 + return BeautifulSoup(resp.text, "html.parser")
45 +
46 + def fetch(self) -> list[Listing]:
47 + listings: dict[str, Listing] = {}
48 + for page in range(1, self.max_pages + 1):
49 + try:
50 + soup = self._ajax_page(page)
51 + except Exception:
52 + break
53 + cards = soup.select(".appartements__bloc")
54 + if not cards:
55 + break
56 + for card in cards:
57 + try:
58 + lst = self._parse_card(card)
59 + except Exception:
60 + continue
61 + if lst and lst.external_id not in listings:
62 + listings[lst.external_id] = lst
63 + # borne réelle de pagination (liens numériques de la réponse)
64 + nums = [int(a.get_text(strip=True))
65 + for a in soup.select(".cvf-universal-pagination li a")
66 + if a.get_text(strip=True).isdigit()]
67 + if nums and page >= max(nums):
68 + break
69 +
70 + # fiches détail (cache BD) : description + galerie
71 + self._fetched = 0
72 + for lst in listings.values():
73 + key = hashlib.sha1(
74 + f"{lst.title}|{lst.availability}|{lst.unit_type}"
75 + .encode("utf-8")).hexdigest()
76 + try:
77 + payload = self.detail(lst.external_id, key,
78 + lambda u=lst.url: self._fetch_detail(u))
79 + except Exception:
80 + continue
81 + if payload.get("description"):
82 + lst.description = payload["description"]
83 + if payload.get("images"):
84 + lst.images = list(dict.fromkeys(payload["images"] + lst.images))[:20]
85 + return list(listings.values())
86 +
87 + # -- carte AJAX -------------------------------------------------------------
88 + def _parse_card(self, card) -> Listing | None:
89 + classes = card.get("class") or []
90 + if "dispo" not in classes:
91 + return None # « loue » = logement loué, exclu
92 + link = card.select_one("a[href*='/appartements/']")
93 + if not link:
94 + return None
95 + url = link["href"].split("?")[0]
96 + m = re.search(r"/appartements/([^/]+)/?$", url.rstrip("/") + "/")
97 + m = re.search(r"/appartements/([^/]+)", url)
98 + if not m:
99 + return None
100 + slug = m.group(1).strip("/")
101 +
102 + title = (link.get("title") or "").strip()
103 + if not title:
104 + h2 = card.select_one("h2")
105 + title = h2.get_text(" ", strip=True) if h2 else slug.replace("-", " ")
106 +
107 + # « À louer » + « À partir du 1 septembre 2026 »
108 + tag = card.select_one(".appartements__dispoTag")
109 + date = card.select_one(".appartements__date")
110 + availability = " ".join(x for x in (
111 + tag.get_text(" ", strip=True) if tag else "",
112 + date.get_text(" ", strip=True) if date else "") if x).strip()
113 +
114 + gr = card.select_one(".appartement__grandeur")
115 + unit_type = normalize_unit_type(gr.get_text(strip=True) if gr else "")
116 + if not re.fullmatch(r"\d½\+?|6½\+|Studio|Loft|Chambre|Maison",
117 + unit_type or ""):
118 + unit_type = ""
119 +
120 + qu = card.select_one(".appartement__quartier")
121 + sector = re.sub(r"\s+", " ",
122 + qu.get_text(" ", strip=True)).strip() if qu else ""
123 +
124 + amenities = []
125 + for li in card.select("li"):
126 + t = re.sub(r"\s+", " ", li.get_text(" ", strip=True))
127 + if t and t not in amenities:
128 + amenities.append(t)
129 +
130 + img = card.select_one("img[src]")
131 + images = []
132 + if img and str(img.get("src", "")).startswith("http"):
133 + images.append(_VARIANT_IMG.sub("", img["src"]))
134 +
135 + return Listing(
136 + source=self.source_id,
137 + external_id=slug,
138 + url=url,
139 + title=title,
140 + address="", # adresse civique non publiée par la source
141 + sector=sector, # « Université »
142 + city="Sherbrooke",
143 + unit_type=unit_type,
144 + availability=availability,
145 + amenities=amenities,
146 + images=images,
147 + )
148 +
149 + # -- fiche appartement --------------------------------------------------------
150 + def _fetch_detail(self, url: str) -> dict:
151 + if self._fetched >= self.max_details:
152 + raise RuntimeError("budget de fiches détail atteint")
153 + self._fetched += 1
154 + html = self.get(url).text
155 + soup = BeautifulSoup(html, "html.parser")
156 + out: dict = {}
157 +
158 + # contenu du billet : listes descriptives (appartement, immeuble, à
159 + # proximité) — tout en texte brut, le textmine central s'en charge
160 + main = soup.select_one("article, .single__content, main") or soup
161 + parts: list[str] = []
162 + for el in main.find_all(["p", "li", "h2", "h3"]):
163 + t = re.sub(r"\s+", " ", el.get_text(" ", strip=True)).strip()
164 + if t and t not in parts:
165 + parts.append(t)
166 + if sum(len(x) for x in parts) > 1500:
167 + break
168 + if parts:
169 + out["description"] = " | ".join(parts)[:1500]
170 +
171 + images = []
172 + for img in soup.select("img[src*='/wp-content/uploads/']"):
173 + src = _VARIANT_IMG.sub("", str(img.get("src") or ""))
174 + if src.startswith("http") and src not in images \
175 + and not re.search(r"logo|icon|favicon", src, re.I):
176 + images.append(src)
177 + out["images"] = images[:20]
178 + return out
added louka/connectors/ascensio.py +188 −0
@@ -0,0 +1,188 @@
1 +# -----------------------------------------------------------------------------
2 +# Lou-Ka — Agrégateur de logements à louer (province de Québec)
3 +# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
4 +# connectors/ascensio.py : connecteur Groupe Ascensio (groupeascensio.com)
5 +# Société immobilière — logements neufs à Sherbrooke (Les Nations :
6 +# arrondissements Jacques-Cartier et Mont-Bellevue) + Pont-Rouge (région de
7 +# Québec). WordPress : la page /logements-a-louer/ est rendue serveur —
8 +# grille `.grid-logements .grid-item` (une carte par logement disponible :
9 +# type + numéro, date de disponibilité, secteur, immeuble, photo, lien
10 +# /location/<slug>/). Les fiches (via self.detail, cache BD) ajoutent le
11 +# numéro de référence stable (external_id, ex. BRY-2030134), la mensualité,
12 +# la description, les pièces et dimensions et la galerie. Seuls les
13 +# logements affichés (tous « Disponible ») deviennent des annonces.
14 +# -----------------------------------------------------------------------------
15 +from __future__ import annotations
16 +
17 +import hashlib
18 +import re
19 +
20 +from bs4 import BeautifulSoup
21 +
22 +from ..schema import Listing, normalize_unit_type, parse_price
23 +from .base import BaseConnector
24 +
25 +BASE = "https://groupeascensio.com"
26 +LIST_URL = f"{BASE}/logements-a-louer/"
27 +
28 +_VARIANT_IMG = re.compile(r"-\d{2,4}x\d{2,4}(?=\.(?:jpg|jpeg|png|webp)$)", re.I)
29 +
30 +
31 +class AscensioConnector(BaseConnector):
32 + source_id = "ascensio"
33 + request_delay = 0.6
34 + max_details = 40 # garde-fou fiches détail (vraies requêtes)
35 +
36 + def fetch(self) -> list[Listing]:
37 + html = self.get(LIST_URL).text
38 + soup = BeautifulSoup(html, "html.parser")
39 +
40 + listings: dict[str, Listing] = {}
41 + for card in soup.select(".grid-logements .grid-item"):
42 + try:
43 + lst = self._parse_card(card)
44 + except Exception:
45 + continue
46 + if lst and lst.external_id not in listings:
47 + listings[lst.external_id] = lst
48 +
49 + # fiches détail (cache BD) : référence, mensualité, description,
50 + # pièces/dimensions, galerie
51 + self._fetched = 0
52 + out: dict[str, Listing] = {}
53 + for slug, lst in listings.items():
54 + key = hashlib.sha1(
55 + f"{lst.title}|{lst.availability}|{lst.sector}"
56 + .encode("utf-8")).hexdigest()
57 + try:
58 + payload = self.detail(slug, key,
59 + lambda u=lst.url: self._fetch_detail(u))
60 + except Exception:
61 + payload = {}
62 + self._apply_detail(lst, payload)
63 + # référence de gestion stable (BRY-2030134) quand publiée
64 + ref = (payload.get("reference") or "").strip()
65 + lst.external_id = ref or slug
66 + if lst.external_id not in out:
67 + out[lst.external_id] = lst
68 + return list(out.values())
69 +
70 + # -- carte de la grille -----------------------------------------------------------
71 + def _parse_card(self, card) -> Listing | None:
72 + link = card.select_one("a[href*='/location/']")
73 + if not link:
74 + return None
75 + url = link["href"]
76 + m = re.search(r"/location/([^/]+)/?", url)
77 + if not m:
78 + return None
79 + slug = m.group(1)
80 +
81 + title_el = card.select_one(".logement-title")
82 + title = re.sub(r"\s+", " ",
83 + title_el.get_text(" ", strip=True)).strip() if title_el else slug
84 +
85 + # « Disponibilité : 01/08/2026 » (bandeau survol)
86 + availability = ""
87 + extra = card.select_one(".extra-infos")
88 + if extra:
89 + m2 = re.search(r"Disponibilit[eé]\s*:?\s*([\d/]+)",
90 + extra.get_text(" ", strip=True))
91 + if m2:
92 + availability = f"Disponible le {m2.group(1)}"
93 +
94 + sector_el = card.select_one(".secteur-title")
95 + sector = ""
96 + if sector_el:
97 + sector = re.sub(r"^\s*Secteur\s*:?\s*", "",
98 + sector_el.get_text(" ", strip=True)).strip(" .")
99 +
100 + imm_el = card.select_one(".immeuble-value")
101 + immeuble = re.sub(r"\s+", " ",
102 + imm_el.get_text(" ", strip=True)).strip() if imm_el else ""
103 +
104 + # ville réelle : Sherbrooke, sauf mention explicite de Pont-Rouge
105 + city = "Pont-Rouge" if re.search(r"pont-rouge", sector, re.I) else "Sherbrooke"
106 +
107 + unit_type = normalize_unit_type(title)
108 + if not re.fullmatch(r"\d½\+?|6½\+|Studio|Loft|Chambre|Maison",
109 + unit_type or ""):
110 + unit_type = ""
111 +
112 + img = card.select_one("img[src]")
113 + images = []
114 + if img and str(img.get("src", "")).startswith("http"):
115 + images.append(_VARIANT_IMG.sub("", img["src"]))
116 +
117 + amenities = [f"Immeuble : {immeuble}"] if immeuble else []
118 + return Listing(
119 + source=self.source_id,
120 + external_id=slug, # remplacé par la référence en aval
121 + url=url,
122 + title=f"{title} — {immeuble}" if immeuble else title,
123 + address=immeuble if re.match(r"^\d", immeuble) else "",
124 + sector=sector,
125 + city=city,
126 + unit_type=unit_type,
127 + availability=availability,
128 + amenities=amenities,
129 + images=images,
130 + )
131 +
132 + # -- fiche logement ---------------------------------------------------------------
133 + def _fetch_detail(self, url: str) -> dict:
134 + if self._fetched >= self.max_details:
135 + raise RuntimeError("budget de fiches détail atteint")
136 + self._fetched += 1
137 + html = self.get(url).text
138 + soup = BeautifulSoup(html, "html.parser")
139 + out: dict = {}
140 +
141 + # paires h5 -> valeur : Référence, Mensualité, Disponibilités
142 + for h in soup.select("h5"):
143 + lab = h.get_text(" ", strip=True).lower()
144 + sib = h.find_next_sibling()
145 + if sib is None:
146 + continue
147 + val = re.sub(r"\s+", " ", sib.get_text(" ", strip=True)).strip()
148 + if "référence" in lab or "reference" in lab:
149 + out["reference"] = val
150 + elif "mensualité" in lab or "mensualite" in lab:
151 + out["price_label"] = val
152 + elif "disponibilités" in lab or "disponibilites" in lab:
153 + out["availability"] = val
154 + elif "pièces et dimensions" in lab and sib.name == "ul":
155 + out["rooms"] = [re.sub(r"\s+", " ", li.get_text(" ", strip=True))
156 + for li in sib.select("li")][:15]
157 +
158 + # description : paragraphes longs du corps de la fiche
159 + paras = [re.sub(r"\s+", " ", p.get_text(" ", strip=True))
160 + for p in soup.select("p")]
161 + longs = [p for p in paras if len(p) > 120]
162 + if longs:
163 + out["description"] = " ".join(longs)[:1500]
164 +
165 + images: list[str] = []
166 + for img in soup.select("img[src*='/wp-content/uploads/']"):
167 + src = _VARIANT_IMG.sub("", str(img.get("src") or ""))
168 + if src.startswith("http") and src not in images \
169 + and not re.search(r"logo|icon|favicon", src, re.I):
170 + images.append(src)
171 + out["images"] = images[:20]
172 + return out
173 +
174 + def _apply_detail(self, lst: Listing, d: dict) -> None:
175 + if not d:
176 + return
177 + if d.get("price_label"):
178 + lst.price_label = d["price_label"] # « 1425 $ / mois »
179 + lst.price = parse_price(re.sub(r"(\d)\s(\d{3})", r"\1\2",
180 + d["price_label"]))
181 + if d.get("availability"):
182 + lst.availability = d["availability"]
183 + if d.get("description"):
184 + lst.description = d["description"]
185 + if d.get("rooms"):
186 + lst.amenities = list(dict.fromkeys(lst.amenities + d["rooms"]))
187 + if d.get("images"):
188 + lst.images = list(dict.fromkeys(d["images"] + lst.images))[:20]
added louka/connectors/bestlife.py +189 −0
@@ -0,0 +1,189 @@
1 +# -----------------------------------------------------------------------------
2 +# Lou-Ka — Agrégateur de logements à louer (province de Québec)
3 +# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
4 +# connectors/bestlife.py : connecteur Les Gestions Bestlife
5 +# (lesgestionsbestlife.com) — 500+ portes en gestion à Sherbrooke
6 +# (Fleurimont, Rock Forest, Mont-Bellevue), East Angus, Richmond.
7 +# WordPress Divi + WooCommerce : chaque logement est un « produit »
8 +# (archive /appartements-a-louer-sherbrooke/, cartes li.product avec titre
9 +# « adresse – type », prix WooCommerce — promo = del/ins — et taxonomie
10 +# product_cat-<type>). Les fiches produit (via self.detail, cache BD)
11 +# ajoutent la disponibilité (« Disponible dès maintenant »), les listes
12 +# Inclusions/Spécifications et la galerie photos. La ville est extraite de
13 +# la parenthèse du titre (« (East-Angus) », « (Richemond) ») — Sherbrooke
14 +# par défaut. external_id = slug du produit (stable).
15 +# -----------------------------------------------------------------------------
16 +from __future__ import annotations
17 +
18 +import hashlib
19 +import re
20 +
21 +from bs4 import BeautifulSoup
22 +
23 +from ..schema import Listing, normalize_unit_type, parse_price
24 +from .base import BaseConnector
25 +
26 +BASE = "https://lesgestionsbestlife.com"
27 +LIST_URL = f"{BASE}/appartements-a-louer-sherbrooke/"
28 +
29 +# « (East-Angus) », « (Richemond) »… -> vraie ville ; sinon Sherbrooke
30 +_CITY_PARENS = {
31 + "east-angus": "East Angus", "east angus": "East Angus",
32 + "richemond": "Richmond", "richmond": "Richmond",
33 + "windsor": "Windsor", "magog": "Magog",
34 +}
35 +_VARIANT_IMG = re.compile(r"[?&](?:resize|fit)=", re.I)
36 +
37 +
38 +def _clean_price_label(label: str) -> str:
39 + """« 1,150 $ » (virgule de milliers WooCommerce) -> compatible parse_price."""
40 + return re.sub(r"(\d),(\d{3})", r"\1\2", label)
41 +
42 +
43 +class BestlifeConnector(BaseConnector):
44 + source_id = "bestlife"
45 + request_delay = 0.6
46 + max_details = 30 # garde-fou fiches produit (vraies requêtes)
47 +
48 + def fetch(self) -> list[Listing]:
49 + html = self.get(LIST_URL).text
50 + soup = BeautifulSoup(html, "html.parser")
51 +
52 + listings: dict[str, Listing] = {}
53 + for card in soup.select("li.product"):
54 + try:
55 + lst = self._parse_card(card)
56 + except Exception:
57 + continue
58 + if lst and lst.external_id not in listings:
59 + listings[lst.external_id] = lst
60 +
61 + # fiches produit (cache BD) : dispo, inclusions, spécifications, photos
62 + self._fetched = 0
63 + for lst in listings.values():
64 + key = hashlib.sha1(
65 + f"{lst.title}|{lst.price_label}".encode("utf-8")).hexdigest()
66 + try:
67 + payload = self.detail(lst.external_id, key,
68 + lambda u=lst.url: self._fetch_detail(u))
69 + except Exception:
70 + continue
71 + self._apply_detail(lst, payload)
72 + return list(listings.values())
73 +
74 + # -- carte produit ---------------------------------------------------------------
75 + def _parse_card(self, card) -> Listing | None:
76 + link = card.select_one("a.woocommerce-loop-product__link[href]")
77 + title_el = card.select_one("h2")
78 + if not (link and title_el):
79 + return None
80 + url = link["href"]
81 + m = re.search(r"/produit/([^/]+)/?", url)
82 + if not m:
83 + return None
84 + slug = m.group(1)
85 + title = re.sub(r"\s+", " ", title_el.get_text(" ", strip=True)).strip()
86 +
87 + # « 1082 Sainte-Thérèse – 4 1/2 » -> adresse + type
88 + addr_part = re.split(r"\s*[–—-]\s*(?=\d\s*1/2|Loft|Studio|Chambre)",
89 + title, maxsplit=1, flags=re.I)[0].strip()
90 + unit_type = normalize_unit_type(title)
91 + if not re.fullmatch(r"\d½\+?|6½\+|Studio|Loft|Chambre|Maison",
92 + unit_type or ""):
93 + unit_type = ""
94 +
95 + # ville depuis la parenthèse du titre (sinon Sherbrooke)
96 + city = "Sherbrooke"
97 + pm = re.search(r"\(([^)]+)\)", title)
98 + if pm:
99 + key = pm.group(1).strip().lower()
100 + if key in _CITY_PARENS:
101 + city = _CITY_PARENS[key]
102 + addr_part = re.sub(r"\s*\([^)]+\)", "", addr_part).strip()
103 +
104 + # prix WooCommerce : promo = <del>régulier</del> <ins>courant</ins>
105 + price = None
106 + price_label = ""
107 + price_el = card.select_one("span.price")
108 + if price_el:
109 + price_label = re.sub(r"\s+", " ",
110 + price_el.get_text(" ", strip=True)).strip()
111 + ins = price_el.select_one("ins .woocommerce-Price-amount")
112 + amount = ins or price_el.select_one(".woocommerce-Price-amount")
113 + if amount:
114 + price = parse_price(_clean_price_label(
115 + amount.get_text(" ", strip=True)))
116 +
117 + img = card.select_one("img[src]")
118 + images = []
119 + if img:
120 + src = (img.get("data-orig-file") or img["src"]).strip()
121 + if src.startswith("http"):
122 + images.append(src)
123 +
124 + return Listing(
125 + source=self.source_id,
126 + external_id=slug,
127 + url=url,
128 + title=title,
129 + address=addr_part,
130 + sector="", # non publié sur la carte
131 + city=city,
132 + unit_type=unit_type,
133 + price=price,
134 + price_label=price_label,
135 + availability="", # complété par la fiche produit
136 + images=images,
137 + )
138 +
139 + # -- fiche produit ------------------------------------------------------------
140 + def _fetch_detail(self, url: str) -> dict:
141 + if self._fetched >= self.max_details:
142 + raise RuntimeError("budget de fiches détail atteint")
143 + self._fetched += 1
144 + html = self.get(url).text
145 + soup = BeautifulSoup(html, "html.parser")
146 + out: dict = {}
147 +
148 + # « Disponible dès maintenant » / « Disponible le 1er septembre » —
149 + # ligne en emphase de la fiche (jamais les messages techniques du thème)
150 + for el in soup.find_all(["em", "strong", "p", "h3"]):
151 + t = re.sub(r"\s+", " ", el.get_text(" ", strip=True)).strip()
152 + if re.match(r"^Disponible\b", t) and len(t) <= 80:
153 + out["availability"] = t
154 + break
155 +
156 + # listes Inclusions / Spécifications (commodités affichées)
157 + amenities: list[str] = []
158 + for h in soup.find_all(["h3", "h4"]):
159 + t = h.get_text(" ", strip=True)
160 + if t in ("Inclusions", "Spécifications"):
161 + ul = h.find_next("ul")
162 + if ul:
163 + for li in ul.select("li"):
164 + item = re.sub(r"\s+", " ", li.get_text(" ", strip=True))
165 + if item and item not in amenities:
166 + amenities.append(item)
167 + out["amenities"] = amenities[:25]
168 +
169 + # galerie photos (pleine taille i0.wp.com sans resize)
170 + images: list[str] = []
171 + for img in soup.select(".woocommerce-product-gallery img[src], "
172 + ".et_pb_gallery img[src]"):
173 + src = (img.get("data-orig-file") or img.get("src") or "").strip()
174 + src = src.split("?")[0] if _VARIANT_IMG.search(src) else src
175 + if src.startswith("http") and src not in images:
176 + images.append(src)
177 + out["images"] = images[:20]
178 + return out
179 +
180 + def _apply_detail(self, lst: Listing, d: dict) -> None:
181 + if not d:
182 + return
183 + if d.get("availability"):
184 + lst.availability = d["availability"]
185 + if d.get("amenities"):
186 + lst.amenities = list(dict.fromkeys(lst.amenities + d["amenities"]))
187 + if d.get("images"):
188 + merged = list(dict.fromkeys(d["images"] + lst.images))
189 + lst.images = merged[:20]
added louka/connectors/dynamic.py +316 −0
@@ -0,0 +1,316 @@
1 +# -----------------------------------------------------------------------------
2 +# Lou-Ka — Agrégateur de logements à louer (province de Québec)
3 +# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
4 +# connectors/dynamic.py : connecteur Gestion immobilière Dynamic
5 +# (lesgestionsdynamic.com) — apparts à Sherbrooke, Magog, Granby, East Angus.
6 +# WordPress + thème immobilier Houzez, même famille que gimcote.py : archive
7 +# /a-louer/ paginée (cartes div.item-listing-wrap avec prix, galerie
8 +# data-images, data-listid). Particularité locale : pas d'adresse ni de
9 +# statut sur la carte — la disponibilité est un suffixe du titre
10 +# (« IMMÉDIATEMENT », « JUILLET », « 1er AOÛT »…) et l'adresse/ville/GPS
11 +# viennent de la fiche détail (bloc #property-address-wrap, carte Houzez).
12 +# Sert de CLASSE DE BASE à la famille Houzez de l'Estrie : Gestimmo Estrie
13 +# (gestimmo_estrie.py) et Agence de location Sherbrooke / groupe Prestiplex
14 +# (agence_sherbrooke.py) n'en redéfinissent que les constantes et les
15 +# crochets carte (statut/étiquette/adresse).
16 +# -----------------------------------------------------------------------------
17 +from __future__ import annotations
18 +
19 +import hashlib
20 +import html as htmllib
21 +import json
22 +import re
23 +
24 +from bs4 import BeautifulSoup
25 +
26 +from ..schema import (Listing, normalize_unit_type, parse_price,
27 + strip_accents)
28 +from .base import BaseConnector
29 +
30 +# variantes redimensionnées WordPress (-584x438.jpg) -> pleine taille
31 +_SIZE_SUFFIX = re.compile(r"-\d{2,4}x\d{2,4}(?=\.(?:jpg|jpeg|png|webp)$)", re.I)
32 +_MAP_LATLNG_RE = re.compile(
33 + r'"lat"\s*:\s*"?(-?\d+\.\d+)"?\s*,\s*"lng"\s*:\s*"?(-?\d+\.\d+)"?')
34 +
35 +# villes réelles desservies par la famille (jamais devinées : on ne retient la
36 +# ville que si elle apparaît telle quelle dans l'adresse ou le bloc « Ville »)
37 +_KNOWN_CITIES = [
38 + "Sherbrooke", "Magog", "Granby", "East Angus", "Orford", "Waterville",
39 + "Windsor", "Coaticook", "Ascot Corner", "Lennoxville", "Richmond",
40 + "Cookshire-Eaton", "Bromptonville", "Cowansville", "Bromont", "Valcourt",
41 +]
42 +
43 +# suffixe de disponibilité dans les titres Dynamic : « IMMÉDIATEMENT »,
44 +# « JUILLET », « 1er AOÛT », « LOUÉ »…
45 +_AVAIL_TITLE_RE = re.compile(
46 + r"(imm[eé]diatement|d[èe]s maintenant|lou[ée]|"
47 + r"(?:1er\s+|15\s+)?(?:janvier|f[ée]vrier|mars|avril|mai|juin|juillet|"
48 + r"ao[ûu]t|septembre|octobre|novembre|d[ée]cembre)(?:\s+20\d\d)?)\s*$",
49 + re.I)
50 +
51 +
52 +def _clean_price_label(label: str) -> str:
53 + """'1,450$/mois' ou '1 450 $/mois' -> compatible parse_price."""
54 + return re.sub(r"(\d)[,\s](\d{3})", r"\1\2", label)
55 +
56 +
57 +def _city_from_parts(parts: list[str]) -> tuple[str, str]:
58 + """(ville, secteur) depuis les segments Nominatim de address.item-address :
59 + « 89, Rue des Pins, East Angus, Le Haut-Saint-François, … » — la ville est
60 + le segment qui correspond à une ville connue, le secteur le segment qui la
61 + précède (micro-quartier) quand il ne fait pas partie de l'adresse civique."""
62 + for i, p in enumerate(parts):
63 + for city in _KNOWN_CITIES:
64 + if strip_accents(p.strip().lower()) == strip_accents(city.lower()):
65 + sector = ""
66 + if i >= 3: # [n° civique, rue, quartier, ville, ...]
67 + sector = parts[i - 1].strip()
68 + return city, sector
69 + return "", ""
70 +
71 +
72 +class DynamicConnector(BaseConnector):
73 + source_id = "dynamic"
74 + request_delay = 0.6
75 + max_pages = 12 # garde-fou de pagination
76 + max_details = 80 # garde-fou fiches détail (vraies requêtes)
77 +
78 + BASE = "https://lesgestionsdynamic.com"
79 + LIST_PATH = "/a-louer/"
80 + CITY_DEFAULT = "Sherbrooke" # repli si la fiche ne précise pas la ville
81 +
82 + def fetch(self) -> list[Listing]:
83 + listings: dict[str, Listing] = {}
84 + for page in range(1, self.max_pages + 1):
85 + url = (f"{self.BASE}{self.LIST_PATH}" if page == 1
86 + else f"{self.BASE}{self.LIST_PATH}page/{page}/")
87 + try:
88 + html = self.get(url).text
89 + except Exception:
90 + break
91 + soup = BeautifulSoup(html, "html.parser")
92 + cards = soup.select("div.item-listing-wrap")
93 + if not cards:
94 + break
95 + for card in cards:
96 + try:
97 + self._parse_card(card, listings)
98 + except Exception:
99 + continue
100 +
101 + # fiches détail (cache BD) : adresse/ville/GPS, description,
102 + # caractéristiques, type d'unité (aperçu Houzez), galerie complète
103 + self._fetched = 0
104 + for lst in listings.values():
105 + card_key = hashlib.sha1(
106 + f"{lst.title}|{lst.price_label}|{lst.availability}"
107 + .encode("utf-8")).hexdigest()
108 + try:
109 + payload = self.detail(lst.external_id, card_key,
110 + lambda u=lst.url: self._fetch_detail(u))
111 + except Exception:
112 + continue
113 + self._apply_detail(lst, payload)
114 + return list(listings.values())
115 +
116 + # -- crochets par site --------------------------------------------------------
117 + def _card_availability(self, card, title: str) -> str:
118 + """Dynamic : la disponibilité est un suffixe du titre de l'annonce."""
119 + m = _AVAIL_TITLE_RE.search(title)
120 + return m.group(1).strip() if m else ""
121 +
122 + # -- carte Houzez ---------------------------------------------------------------
123 + def _parse_card(self, card, listings: dict[str, Listing]) -> None:
124 + link = card.select_one("h2.item-title a[href]")
125 + if not link:
126 + return
127 + url = link["href"]
128 + title = re.sub(r"\s+", " ", link.get_text(" ", strip=True)).strip()
129 + m = re.search(r"/(?:property|appartement)/([^/]+)/?", url)
130 + slug = m.group(1) if m else ""
131 + listid_el = card.select_one("[data-listid]")
132 + ext_id = (listid_el.get("data-listid") if listid_el else "") or slug
133 + if not ext_id or str(ext_id) in listings:
134 + return
135 +
136 + # exclusions : logements loués + espaces non résidentiels
137 + if re.search(r"\blou[ée]s?\b", title, re.I):
138 + return
139 + if re.search(r"stationnement|commercial|rangement|garage|entrep[oô]t",
140 + title, re.I):
141 + return
142 + availability = self._card_availability(card, title)
143 + if re.search(r"lou[ée]", availability, re.I):
144 + return
145 +
146 + price_el = card.select_one("li.item-price")
147 + price_label = price_el.get_text(" ", strip=True) if price_el else ""
148 +
149 + # adresse Nominatim de la carte (présente chez Agence, absente chez
150 + # Dynamic/Gestimmo — la fiche détail prendra le relais)
151 + address = sector = ""
152 + city = self.CITY_DEFAULT
153 + addr_el = card.select_one("address.item-address")
154 + if addr_el:
155 + full = addr_el.get_text(" ", strip=True)
156 + parts = [p.strip() for p in full.split(",") if p.strip()]
157 + address = ", ".join(parts[:2]) if len(parts) >= 2 else full
158 + c, s = _city_from_parts(parts)
159 + if c:
160 + city, sector = c, s
161 +
162 + # commodités des cartes Houzez : chambres / salles de bain / pi²
163 + amenities: list[str] = []
164 + for li in card.select("ul.item-amenities li"):
165 + t = re.sub(r"\s+", " ", li.get_text(" ", strip=True))
166 + t = t.replace("Beds:", "Chambres :").replace("Bath:", "Salle(s) de bain :")
167 + if t and t not in amenities:
168 + amenities.append(t)
169 +
170 + # galerie : attribut data-images (JSON, URLs redimensionnées)
171 + images: list[str] = []
172 + raw = card.get("data-images") or ""
173 + if raw:
174 + try:
175 + urls = json.loads(htmllib.unescape(raw))
176 + except Exception:
177 + urls = re.findall(r"https?:[^\"',\\]+", htmllib.unescape(raw))
178 + for u in urls:
179 + if isinstance(u, dict): # variante Houzez : objets {url: …}
180 + u = u.get("url") or u.get("src") or u.get("image") or ""
181 + if not isinstance(u, str):
182 + continue
183 + u = u.replace("\\/", "/").strip()
184 + if u.startswith("http"):
185 + u = _SIZE_SUFFIX.sub("", u)
186 + if u not in images:
187 + images.append(u)
188 + if not images:
189 + thumb = card.select_one("img.wp-post-image[src]")
190 + if thumb:
191 + images = [_SIZE_SUFFIX.sub("", thumb["src"])]
192 +
193 + # type d'unité depuis le titre, seulement si le motif est net
194 + # (normalize_unit_type retourne le texte brut quand rien ne matche)
195 + unit_type = normalize_unit_type(title)
196 + if not re.fullmatch(r"\d½\+?|6½\+|Studio|Loft|Chambre|Maison",
197 + unit_type or ""):
198 + unit_type = ""
199 +
200 + listings[str(ext_id)] = Listing(
201 + source=self.source_id,
202 + external_id=str(ext_id),
203 + url=url,
204 + title=title,
205 + address=address,
206 + sector=sector,
207 + city=city,
208 + unit_type=unit_type,
209 + price=parse_price(_clean_price_label(price_label)),
210 + price_label=price_label,
211 + availability=availability,
212 + amenities=amenities,
213 + images=images[:30],
214 + )
215 +
216 + # -- fiche détail (Houzez) -----------------------------------------------------
217 + def _fetch_detail(self, url: str) -> dict:
218 + """Adresse structurée (#property-address-wrap), description,
219 + caractéristiques, type d'unité (aperçu) et GPS (carte Houzez)."""
220 + if self._fetched >= self.max_details:
221 + raise RuntimeError("budget de fiches détail atteint")
222 + self._fetched += 1
223 + html = self.get(url).text
224 + soup = BeautifulSoup(html, "html.parser")
225 + out: dict = {}
226 +
227 + desc_el = soup.select_one("#property-description-wrap")
228 + if desc_el:
229 + txt = desc_el.get_text("\n", strip=True)
230 + txt = re.sub(r"^Description\n", "", txt)
231 + out["description"] = re.sub(r"[ \t]+", " ", txt).strip()[:1500]
232 +
233 + out["amenities"] = [a.get_text(" ", strip=True)
234 + for a in soup.select("#property-features-wrap li")
235 + if a.get_text(strip=True)][:25]
236 +
237 + # bloc adresse : « Adresse | 375 rue terrill | Ville |
238 + # Fleurimont (Sherbrooke) | Code postal | J1E 3S7 »
239 + for li in soup.select("#property-address-wrap li"):
240 + st, sp = li.find("strong"), li.find("span")
241 + if not (st and sp):
242 + continue
243 + lab = strip_accents(st.get_text(" ", strip=True).lower())
244 + val = sp.get_text(" ", strip=True)
245 + if lab.startswith("adresse"):
246 + out["address"] = val
247 + elif lab.startswith("ville"):
248 + out["city_raw"] = val
249 + elif "postal" in lab:
250 + out["postal"] = val
251 +
252 + # adresse Nominatim complète (repli ville/secteur)
253 + addr_el = soup.select_one("address.item-address")
254 + if addr_el:
255 + out["item_address"] = addr_el.get_text(" ", strip=True)
256 +
257 + # type d'unité : aperçu Houzez (« Appartement 4 1/2 ») — exiger un
258 + # motif net (« … 4 1/2 », « Studio »…), jamais le mot « chambres » du
259 + # compteur de pièces
260 + ov = soup.select_one(".property-overview-wrap, #property-overview-wrap")
261 + if ov:
262 + m = re.search(r"(\d\s*(?:1/2|½)|\bstudio\b|\bloft\b|\bmaison\b)",
263 + ov.get_text(" ", strip=True), re.I)
264 + if m:
265 + out["type_raw"] = m.group(1)
266 +
267 + m = _MAP_LATLNG_RE.search(html)
268 + if m:
269 + out["lat"], out["lng"] = float(m.group(1)), float(m.group(2))
270 + return out
271 +
272 + def _apply_detail(self, lst: Listing, d: dict) -> None:
273 + """Reporte le payload (frais ou cache BD) sur l'annonce."""
274 + if not d:
275 + return
276 + if d.get("description"):
277 + lst.description = d["description"]
278 + if d.get("amenities"):
279 + lst.amenities = list(dict.fromkeys(lst.amenities + d["amenities"]))
280 +
281 + # adresse structurée de la fiche ; « Ville » au format
282 + # « Fleurimont (Sherbrooke) » (secteur (ville)) ou « Magog »
283 + if d.get("address") and not lst.address:
284 + lst.address = d["address"]
285 + city_raw = (d.get("city_raw") or "").strip()
286 + if city_raw:
287 + m = re.match(r"^(.*?)\s*\((.+)\)\s*$", city_raw)
288 + inner = (m.group(2).strip() if m else city_raw)
289 + outer = (m.group(1).strip() if m else "")
290 + c, _ = _city_from_parts([inner])
291 + if c: # « Fleurimont (Sherbrooke) »
292 + lst.city = c
293 + if outer and not lst.sector:
294 + lst.sector = outer
295 + else:
296 + c2, _ = _city_from_parts([city_raw])
297 + if c2: # « Magog »
298 + lst.city = c2
299 + elif not lst.sector: # « Nord », « Centre-ville »…
300 + lst.sector = city_raw
301 + elif d.get("item_address"):
302 + parts = [p.strip() for p in d["item_address"].split(",") if p.strip()]
303 + c, s = _city_from_parts(parts)
304 + if c:
305 + lst.city = c
306 + if s and not lst.sector:
307 + lst.sector = s
308 + if not lst.address and d.get("item_address"):
309 + parts = [p.strip() for p in d["item_address"].split(",") if p.strip()]
310 + if len(parts) >= 2:
311 + lst.address = ", ".join(parts[:2])
312 +
313 + if not lst.unit_type and d.get("type_raw"):
314 + lst.unit_type = normalize_unit_type(d["type_raw"])
315 + if d.get("lat") is not None and d.get("lng") is not None:
316 + lst.lat, lst.lng = d["lat"], d["lng"]
added louka/connectors/floria.py +139 −0
@@ -0,0 +1,139 @@
1 +# -----------------------------------------------------------------------------
2 +# Lou-Ka — Agrégateur de logements à louer (province de Québec)
3 +# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
4 +# connectors/floria.py : connecteur Gestion Floria (gestionfloria.ca)
5 +# Condos locatifs neufs à Sherbrooke, Magog (Mont-Orford) et Coaticook.
6 +# Site WordPress (Avada) : chaque page /immeuble/<slug>/ embarque le module
7 +# de plans interactifs Livya (app.livya.com, client « gestion-floria », un
8 +# projet/entité par immeuble). Même patron que somex_saintnicolas/louis14 :
9 +# la page Next.js du module est rendue serveur et son flux RSC contient
10 +# l'inventaire JSON complet (numéro, statut, loyer, pièces, superficie,
11 +# adresse, ville, GPS, photos, plans). Découverte des immeubles via la page
12 +# /secteurs/. Certains immeubles partagent le même projet Livya (jumelés
13 +# 52/58 Flanc-Sud, 753/765 Rachel-Hébert…) : dédoublonnage par unitId.
14 +# Seules les unités AVAILABLE deviennent des annonces ; certains projets ne
15 +# publient pas le loyer (rentalPrice = 0) -> prix absent, rien d'inventé.
16 +# -----------------------------------------------------------------------------
17 +from __future__ import annotations
18 +
19 +import re
20 +
21 +from ..schema import Listing
22 +from .base import BaseConnector
23 +from .somex_saintnicolas import _livya_units, _unit_type
24 +
25 +BASE = "https://gestionfloria.ca"
26 +SECTORS_URL = f"{BASE}/secteurs/"
27 +LIVYA = "https://app.livya.com"
28 +
29 +_IMMEUBLE_RE = re.compile(r"https://gestionfloria\.ca/immeuble/[a-z0-9-]+/")
30 +_MODULE_RE = re.compile(
31 + r'<div class="livya-module-container-plans"[^>]*'
32 + r'data-project="([^"]+)"[^>]*data-entity="([^"]+)"')
33 +_CLIENT_RE = re.compile(r'data-client="([^"]+)"')
34 +
35 +
36 +class FloriaConnector(BaseConnector):
37 + source_id = "floria"
38 + request_delay = 0.7
39 + max_buildings = 20 # garde-fou (12 immeubles publiés)
40 +
41 + def fetch(self) -> list[Listing]:
42 + # 1) Découverte : pages immeuble listées sur /secteurs/
43 + sec = self.get(SECTORS_URL).text
44 + pages = sorted(set(_IMMEUBLE_RE.findall(sec)))
45 +
46 + listings: dict[str, Listing] = {}
47 + for page_url in pages[: self.max_buildings]:
48 + try:
49 + html = self.get(page_url).text
50 + except Exception:
51 + continue
52 + m = _MODULE_RE.search(html)
53 + cm = _CLIENT_RE.search(html)
54 + if not (m and cm):
55 + continue # immeuble sans module Livya (ex. 2835 Mézy)
56 + project, entity, client = m.group(1), m.group(2), cm.group(1)
57 + try:
58 + livya_html = self.get(
59 + f"{LIVYA}/fr/{client}/projects/{project}/plans/{entity}"
60 + f"?noLayout=1").text
61 + except Exception:
62 + continue
63 + for u in _livya_units(livya_html):
64 + # dédoublonnage : les immeubles jumelés partagent le projet
65 + uid = str(u.get("unitId") or "")
66 + if not uid or uid in listings:
67 + continue
68 + if u.get("availability") != "AVAILABLE" or not u.get("rental", True):
69 + continue
70 + listings[uid] = self._listing(u, page_url)
71 + return list(listings.values())
72 +
73 + # -- une annonce par unité disponible ------------------------------------------
74 + def _listing(self, u: dict, page_url: str) -> Listing:
75 + num = str(u.get("number") or "").strip()
76 + price = u.get("rentalPrice")
77 + price = float(price) if isinstance(price, (int, float)) and price > 0 else None
78 + area = u.get("unitSize")
79 + area = float(area) if isinstance(area, (int, float)) and area > 0 else None
80 +
81 + street = (u.get("address") or "").strip()
82 + city = (u.get("city") or "").strip()
83 + postal = (u.get("postalCode") or "").strip()
84 + address = ", ".join(x for x in (street, postal) if x)
85 +
86 + # description : étage, modèle, pièces, balcon, plan (champs structurés
87 + # du flux — le textmine central en tire les dérivés)
88 + desc: list[str] = []
89 + floor = str(u.get("floorNumber") or "").strip()
90 + if floor:
91 + desc.append(f"Étage {floor}")
92 + if u.get("typeName"):
93 + desc.append(f"Modèle {u['typeName']}")
94 + if u.get("roomsBed"):
95 + desc.append(f"{u['roomsBed']} chambre(s)")
96 + if u.get("roomsBath"):
97 + desc.append(f"{u['roomsBath']} salle(s) de bain")
98 + if u.get("balconySize"):
99 + desc.append(f"Balcon de {u['balconySize']} pi²")
100 + if u.get("floorPlanUrl"):
101 + desc.append(f"Plan : {u['floorPlanUrl']}")
102 +
103 + images = [img.get("fullUrl") for img in (u.get("typeImages") or [])
104 + if isinstance(img, dict) and img.get("fullUrl")]
105 + if u.get("floorPlanImageUrl"):
106 + images.append(u["floorPlanImageUrl"])
107 +
108 + future = u.get("futureAvailability")
109 + availability = str(future) if future else "Disponible"
110 +
111 + details: dict = {}
112 + if floor.isdigit():
113 + details["floor"] = int(floor)
114 +
115 + lat, lng = u.get("latitude"), u.get("longitude")
116 + unit_type = _unit_type(u.get("rooms"))
117 + title = f"{street} — unité {num}" if street else f"Unité {num}"
118 + if unit_type:
119 + title += f" ({unit_type})"
120 +
121 + return Listing(
122 + source=self.source_id,
123 + external_id=str(u["unitId"]),
124 + url=page_url, # la page immeuble héberge le sélecteur
125 + title=title,
126 + address=address,
127 + sector="", # secteur non publié unité par unité
128 + city=city,
129 + unit_type=unit_type,
130 + price=price,
131 + price_label=f"{price:.0f} $ /mois" if price else "",
132 + availability=availability,
133 + area_sqft=area,
134 + description=" | ".join(desc),
135 + details=details,
136 + images=images[:12],
137 + lat=float(lat) if lat else None,
138 + lng=float(lng) if lng else None,
139 + )
added louka/connectors/gestimmo_estrie.py +48 −0
@@ -0,0 +1,48 @@
1 +# -----------------------------------------------------------------------------
2 +# Lou-Ka — Agrégateur de logements à louer (province de Québec)
3 +# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
4 +# connectors/gestimmo_estrie.py : connecteur Gestimmo Estrie (gestimmoestrie.com)
5 +# Gestionnaire multi-immeubles de Sherbrooke et de l'Estrie. Même plateforme
6 +# WordPress + thème Houzez que Gestion Dynamic : tout le parsing (cartes,
7 +# pagination /a-louer/page/N/, fiches détail, cache BD) est hérité de
8 +# DynamicConnector. Particularités du site :
9 +# - la disponibilité est l'étiquette de statut de la carte
10 +# (lien /status/ : « Libre maintenant », « Juillet », « Loué »…) ;
11 +# - les fiches n'ont pas d'aperçu Houzez : le type d'unité vient du titre
12 +# (« 4 1/2 Rue de la Sainte-Famille ») ou de la ligne « Grandeur : 4 1/2 »
13 +# de la description.
14 +# Les logements « Loué » sont exclus (filtre hérité).
15 +# -----------------------------------------------------------------------------
16 +from __future__ import annotations
17 +
18 +import re
19 +
20 +from .dynamic import DynamicConnector
21 +
22 +# « Grandeur : 4 1/2 » / « Grandeur: Studio » dans la description des fiches
23 +_SIZE_IN_DESC = re.compile(r"grandeur\s*:?\s*(\d\s*1/2|\d\s*½|studio|loft)", re.I)
24 +
25 +
26 +class GestimmoEstrieConnector(DynamicConnector):
27 + source_id = "gestimmo_estrie"
28 +
29 + BASE = "https://gestimmoestrie.com"
30 + LIST_PATH = "/a-louer/"
31 + CITY_DEFAULT = "Sherbrooke"
32 +
33 + # -- crochets par site --------------------------------------------------------
34 + def _card_availability(self, card, title: str) -> str:
35 + """Gestimmo : étiquette de statut de la carte (« Libre maintenant »,
36 + « Juillet », « Loué »…)."""
37 + status_el = card.select_one("a[href*='/status/']")
38 + return status_el.get_text(" ", strip=True) if status_el else ""
39 +
40 + def _fetch_detail(self, url: str) -> dict:
41 + """Fiche Houzez sans bloc aperçu : repli type d'unité sur la ligne
42 + « Grandeur : … » de la description."""
43 + out = super()._fetch_detail(url)
44 + if not out.get("type_raw") and out.get("description"):
45 + m = _SIZE_IN_DESC.search(out["description"])
46 + if m:
47 + out["type_raw"] = m.group(1)
48 + return out
added louka/connectors/immeubles_db.py +133 −0
@@ -0,0 +1,133 @@
1 +# -----------------------------------------------------------------------------
2 +# Lou-Ka — Agrégateur de logements à louer (province de Québec)
3 +# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
4 +# connectors/immeubles_db.py : connecteur Les Immeubles D.B. Busque-Massé
5 +# (immeublesdb.com) — 12 immeubles / ~400 apparts à Sherbrooke, 4 secteurs.
6 +# Site custom PHP (« pm_editor », derrière Cloudflare — le UA de base.py
7 +# passe) : 4 pages statiques /logements-a-louer/secteur-{nord,est,
8 +# centre-ville,ouest}/. Chaque logement offert = une section .container
9 +# avec une cellule galerie (photos /modules/upload/…) et une cellule texte
10 +# (h3 = adresse civique, liste <li> = type, prix « … $ par mois »,
11 +# inclusions). Aucun identifiant publié : external_id = empreinte stable
12 +# (secteur + adresse + ligne de type). Les logements loués sont simplement
13 +# retirés de la page (aucun marqueur « complet » à filtrer).
14 +# -----------------------------------------------------------------------------
15 +from __future__ import annotations
16 +
17 +import hashlib
18 +import re
19 +
20 +from bs4 import BeautifulSoup
21 +
22 +from ..schema import Listing, normalize_unit_type, parse_price
23 +from .base import BaseConnector
24 +
25 +BASE = "https://immeublesdb.com"
26 +SECTORS = {
27 + "secteur-nord": "Nord",
28 + "secteur-est": "Est",
29 + "secteur-centre-ville": "Centre-ville",
30 + "secteur-ouest": "Ouest",
31 +}
32 +
33 +_PRICE_LI = re.compile(r"\d[\d\s]{0,5}\s?\$\s*par mois", re.I)
34 +
35 +
36 +def _clean_price_label(label: str) -> str:
37 + """« 1 125$ par mois » (espace de milliers) -> compatible parse_price."""
38 + return re.sub(r"(\d)\s(\d{3})", r"\1\2", label)
39 +
40 +
41 +class ImmeublesDbConnector(BaseConnector):
42 + source_id = "immeubles_db"
43 + request_delay = 0.6
44 +
45 + def fetch(self) -> list[Listing]:
46 + listings: dict[str, Listing] = {}
47 + for slug, sector in SECTORS.items():
48 + try:
49 + html = self.get(f"{BASE}/logements-a-louer/{slug}/").text
50 + except Exception:
51 + continue
52 + soup = BeautifulSoup(html, "html.parser")
53 + for container in soup.select("div.container"):
54 + try:
55 + lst = self._parse_block(container, sector)
56 + except Exception:
57 + continue
58 + if lst and lst.external_id not in listings:
59 + listings[lst.external_id] = lst
60 + return list(listings.values())
61 +
62 + # -- une section .container = un logement offert --------------------------------
63 + def _parse_block(self, container, sector: str) -> Listing | None:
64 + h3 = container.select_one(".cell_container h3")
65 + ul = container.select_one(".cell_container ul")
66 + if not (h3 and ul):
67 + return None
68 + address_full = re.sub(r"\s+", " ", h3.get_text(" ", strip=True)).strip(" ,")
69 + lis = [re.sub(r"\s+", " ", li.get_text(" ", strip=True)).strip()
70 + for li in ul.select("li")]
71 + lis = [t for t in lis if t]
72 + if not (address_full and lis):
73 + return None
74 +
75 + # « 250, Olivier, Sherbrooke, QC » -> adresse sans la province
76 + parts = [p.strip() for p in address_full.split(",") if p.strip()]
77 + address = ", ".join(p for p in parts if p.upper() != "QC")
78 + city = "Sherbrooke"
79 +
80 + type_line = lis[0]
81 + # « 4 CHAMBRES disponibles à partir de 550 $ » = location à la chambre
82 + # (normalize_unit_type transformerait « 4 chambres » en 6½+)
83 + if re.search(r"chambres?\s+disponibles?", type_line, re.I):
84 + unit_type = "Chambre"
85 + else:
86 + unit_type = normalize_unit_type(type_line)
87 + if not re.fullmatch(r"\d½\+?|6½\+|Studio|Loft|Chambre|Maison",
88 + unit_type or ""):
89 + unit_type = ""
90 +
91 + # prix : première ligne « … $ par mois »
92 + price = None
93 + price_label = ""
94 + for t in lis:
95 + if _PRICE_LI.search(t):
96 + price_label = t
97 + price = parse_price(_clean_price_label(t))
98 + break
99 +
100 + # disponibilité : seulement si la source l'écrit (sinon vide)
101 + availability = ""
102 + m = re.search(r"libre\s+imm[ée]diatement", " ".join(lis), re.I)
103 + if m:
104 + availability = "Libre immédiatement"
105 +
106 + # photos de la galerie jumelle (chemins relatifs /modules/upload/…)
107 + images: list[str] = []
108 + for img in container.select(".galerie_img_block a[href]"):
109 + href = (img.get("href") or "").strip()
110 + if href.startswith("/"):
111 + href = BASE + href
112 + if href.startswith("http") and href not in images:
113 + images.append(href)
114 +
115 + ext_id = hashlib.sha1(
116 + f"{sector}|{address_full}|{type_line}".encode("utf-8")).hexdigest()[:16]
117 +
118 + return Listing(
119 + source=self.source_id,
120 + external_id=ext_id,
121 + url=f"{BASE}/logements-a-louer/"
122 + f"{[k for k, v in SECTORS.items() if v == sector][0]}/",
123 + title=f"{type_line} — {address}",
124 + address=address,
125 + sector=sector,
126 + city=city,
127 + unit_type=unit_type,
128 + price=price,
129 + price_label=price_label,
130 + availability=availability,
131 + description=" | ".join(lis)[:1500],
132 + images=images[:20],
133 + )
added louka/connectors/labonte.py +193 −0
@@ -0,0 +1,193 @@
1 +# -----------------------------------------------------------------------------
2 +# Lou-Ka — Agrégateur de logements à louer (province de Québec)
3 +# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
4 +# connectors/labonte.py : connecteur Gestion Labonté (gestionlabonte.com)
5 +# Gestionnaire établi de Sherbrooke (66 ans). Site Wix : la page /logements
6 +# est rendue serveur — répéteur Wix dont chaque item
7 +# (div id="comp-…__<guid>") porte le prix (« À partir de N $/mois »),
8 +# l'adresse (h2), le nombre de pièces, le secteur, la photo et le lien vers
9 +# la page dynamique /logements/<guid> (le GUID du CMS Wix = external_id
10 +# stable). Les fiches détail (via self.detail, cache BD) ajoutent la
11 +# description, les paires « Détails du logement » (secteur, pièces,
12 +# chambres, étage) et l'adresse complète du bloc « Emplacement ». La galerie
13 +# photos des fiches est chargée côté client (pro-gallery, non SSR) : seule
14 +# la photo de la carte est disponible. Aucun statut « loué » affiché — la
15 +# liste ne montre que l'inventaire courant.
16 +# -----------------------------------------------------------------------------
17 +from __future__ import annotations
18 +
19 +import hashlib
20 +import re
21 +
22 +from bs4 import BeautifulSoup
23 +
24 +from ..schema import Listing, normalize_unit_type, parse_price
25 +from .base import BaseConnector
26 +
27 +BASE = "https://www.gestionlabonte.com"
28 +LIST_URL = f"{BASE}/logements"
29 +
30 +_GUID_RE = re.compile(r"/logements/([0-9a-f-]{36})")
31 +
32 +# villes possibles dans l'adresse « Emplacement » (jamais devinées)
33 +_CITY_RE = re.compile(r"\b(Sherbrooke|Magog|East Angus|Lennoxville)\b", re.I)
34 +
35 +
36 +def _clean_unit_type(raw: str) -> str:
37 + """normalize_unit_type, mais seulement si le motif est net (« 3.5 »,
38 + « 4,5 », « studio »…) — jamais le texte brut en guise de type."""
39 + ut = normalize_unit_type(raw)
40 + if re.fullmatch(r"\d½\+?|6½\+|Studio|Loft|Chambre|Maison", ut or ""):
41 + return ut
42 + return ""
43 +
44 +
45 +def _lines(el) -> list[str]:
46 + """Lignes de texte nettoyées d'un sous-arbre."""
47 + out = []
48 + for raw in el.get_text("\n", strip=True).split("\n"):
49 + t = re.sub(r"\s+", " ", raw).strip()
50 + if t:
51 + out.append(t)
52 + return out
53 +
54 +
55 +class LabonteConnector(BaseConnector):
56 + source_id = "labonte"
57 + request_delay = 0.7
58 + max_details = 25 # garde-fou fiches détail (vraies requêtes)
59 +
60 + def fetch(self) -> list[Listing]:
61 + html = self.get(LIST_URL).text
62 + soup = BeautifulSoup(html, "html.parser")
63 +
64 + listings: dict[str, Listing] = {}
65 + # items du répéteur : conteneurs suffixés par le GUID de l'item CMS
66 + for item in soup.select('div[id*="__"]'):
67 + link = item.select_one('a[href*="/logements/"]')
68 + if not link:
69 + continue
70 + m = _GUID_RE.search(link.get("href") or "")
71 + if not m:
72 + continue
73 + guid = m.group(1)
74 + iid = (item.get("id") or "")
75 + if not iid.endswith(f"__{guid}") or guid in listings:
76 + continue # garder le conteneur d'item complet, une fois
77 +
78 + lines = _lines(item)
79 + # « À partir de | 1150 | $/mois | 40 rue St-François |
80 + # Nombre de pièces | 3.5 | Secteur | Centre-ville | En savoir plus »
81 + h2 = item.select_one("h2")
82 + address = re.sub(r"\s+", " ", h2.get_text(" ", strip=True)) if h2 else ""
83 +
84 + price = None
85 + price_label = ""
86 + for i, t in enumerate(lines):
87 + if t.lower().startswith("à partir de") and i + 1 < len(lines):
88 + amount = lines[i + 1]
89 + unit = lines[i + 2] if i + 2 < len(lines) else ""
90 + price_label = f"À partir de {amount} {unit}".strip()
91 + price = parse_price(f"{amount} $")
92 + break
93 +
94 + pieces = sector = ""
95 + for i, t in enumerate(lines):
96 + if t.lower().startswith("nombre de pièces") and i + 1 < len(lines):
97 + pieces = lines[i + 1]
98 + elif t.lower() == "secteur" and i + 1 < len(lines):
99 + sector = lines[i + 1]
100 +
101 + img = item.select_one('img[src*="static.wixstatic.com/media"]')
102 + images = []
103 + if img:
104 + images.append(img["src"].split("/v1/")[0])
105 +
106 + listings[guid] = Listing(
107 + source=self.source_id,
108 + external_id=guid,
109 + url=f"{BASE}/logements/{guid}",
110 + title=address or f"Logement {guid[:8]}",
111 + address=address,
112 + sector=sector,
113 + city="Sherbrooke",
114 + unit_type=_clean_unit_type(pieces),
115 + price=price,
116 + price_label=price_label,
117 + availability="", # non publié par la source
118 + images=images,
119 + )
120 +
121 + # fiches détail (cache BD) : description, chambres/étage, adresse complète
122 + self._fetched = 0
123 + for lst in listings.values():
124 + key = hashlib.sha1(
125 + f"{lst.title}|{lst.price_label}|{lst.sector}"
126 + .encode("utf-8")).hexdigest()
127 + try:
128 + payload = self.detail(lst.external_id, key,
129 + lambda u=lst.url: self._fetch_detail(u))
130 + except Exception:
131 + continue
132 + self._apply_detail(lst, payload)
133 + return list(listings.values())
134 +
135 + # -- fiche détail (page dynamique Wix) -------------------------------------------
136 + def _fetch_detail(self, url: str) -> dict:
137 + if self._fetched >= self.max_details:
138 + raise RuntimeError("budget de fiches détail atteint")
139 + self._fetched += 1
140 + html = self.get(url).text
141 + soup = BeautifulSoup(html, "html.parser")
142 + lines = _lines(soup.body or soup)
143 + out: dict = {}
144 +
145 + # description : entre « Description » et « Détails du logement »
146 + try:
147 + i = lines.index("Description")
148 + j = lines.index("Détails du logement")
149 + if 0 <= i < j:
150 + out["description"] = " ".join(lines[i + 1:j])[:1500]
151 + except ValueError:
152 + pass
153 +
154 + # paires « Détails du logement » : Secteur / pièces / chambres / Étage
155 + for i, t in enumerate(lines):
156 + low = t.lower()
157 + if i + 1 >= len(lines):
158 + break
159 + if low == "secteur":
160 + out["sector"] = lines[i + 1]
161 + elif low.startswith("nombre de pièces"):
162 + out["pieces"] = lines[i + 1]
163 + elif low.startswith("nombre de chambres"):
164 + out["bedrooms"] = lines[i + 1]
165 + elif low == "étage":
166 + out["floor"] = lines[i + 1]
167 + elif low == "emplacement":
168 + out["full_address"] = lines[i + 1]
169 + return out
170 +
171 + def _apply_detail(self, lst: Listing, d: dict) -> None:
172 + if not d:
173 + return
174 + if d.get("description"):
175 + lst.description = d["description"]
176 + if d.get("sector") and not lst.sector:
177 + lst.sector = d["sector"]
178 + if d.get("full_address"):
179 + full = d["full_address"]
180 + # « 49 Rue King Ouest, Sherbrooke, QC J1H 1P1, Canada »
181 + lst.address = ", ".join(p.strip() for p in full.split(",")[:2])
182 + m = _CITY_RE.search(full)
183 + if m:
184 + lst.city = m.group(1).title()
185 + if not lst.unit_type and d.get("pieces"):
186 + lst.unit_type = _clean_unit_type(d["pieces"])
187 + details: dict = {}
188 + if str(d.get("bedrooms") or "").isdigit():
189 + details["bedrooms"] = int(d["bedrooms"])
190 + if str(d.get("floor") or "").isdigit():
191 + details["floor"] = int(d["floor"])
192 + if details:
193 + lst.details = {**lst.details, **details}
added louka/connectors/lelaureat.py +136 −0
@@ -0,0 +1,136 @@
1 +# -----------------------------------------------------------------------------
2 +# Lou-Ka — Agrégateur de logements à louer (province de Québec)
3 +# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
4 +# connectors/lelaureat.py : connecteur Résidences Le Lauréat
5 +# (residences-lelaureat.com) — 107 studios étudiants tout inclus rénovés au
6 +# 2145, rue Galt Ouest, Sherbrooke (bail Régie du logement, non-fumeur,
7 +# occupation simple). Site WordPress WPBakery d'une seule page : la section
8 +# « Dimensions des studios » publie 5 TYPES d'unités (Studio Type, Centre
9 +# Arrière, Coin Est, Coin Ouest, Loft) avec dimensions et prix par variante
10 +# (étage / demi-sous-sol). Granularité = type d'unité (aucune unité
11 +# individuelle publiée), comme sig.py. Les inclusions communes (« Notre
12 +# service tout inclus englobe ») sont reprises en commodités. 1 requête.
13 +# -----------------------------------------------------------------------------
14 +from __future__ import annotations
15 +
16 +import re
17 +
18 +from bs4 import BeautifulSoup
19 +
20 +from ..schema import Listing, strip_accents
21 +from .base import BaseConnector
22 +
23 +BASE = "https://www.residences-lelaureat.com"
24 +ADDRESS = "2145 Galt Ouest, Sherbrooke, J1K 3A8"
25 +
26 +_AMOUNT_RE = re.compile(r"\$\s?(\d{3,4})")
27 +_VARIANT_IMG = re.compile(r"-\d{2,4}x\d{2,4}(?=\.(?:jpg|jpeg|png|webp)$)", re.I)
28 +
29 +
30 +def _slug(name: str) -> str:
31 + s = strip_accents(name.strip().lower())
32 + return re.sub(r"[^a-z0-9]+", "-", s).strip("-")
33 +
34 +
35 +class LelaureatConnector(BaseConnector):
36 + source_id = "lelaureat"
37 + request_delay = 0.6
38 +
39 + def fetch(self) -> list[Listing]:
40 + html = self.get(f"{BASE}/").text
41 + soup = BeautifulSoup(html, "html.parser")
42 +
43 + # inclusions communes : listes de la section « tout inclus »
44 + common: list[str] = []
45 + for marker in ("Notre service tout inclus englobe",
46 + "Nos appartements sont équipés"):
47 + el = soup.find(string=re.compile(marker))
48 + if not el:
49 + continue
50 + ul = el.parent.find_next("ul")
51 + if ul:
52 + for li in ul.select("li"):
53 + t = re.sub(r"\s+", " ",
54 + li.get_text(" ", strip=True)).strip(" ►")
55 + if t and t not in common:
56 + common.append(t)
57 +
58 + # galerie du site (photos des studios)
59 + gallery: list[str] = []
60 + for img in soup.select("img[src*='/wp-content/uploads/']"):
61 + src = _VARIANT_IMG.sub("", str(img.get("src") or ""))
62 + if src.startswith("http") and src not in gallery \
63 + and re.search(r"room-|logement|Un-logement", src):
64 + gallery.append(src)
65 +
66 + # 5 types d'unités : titres « Studio … » / « Loft » de la section
67 + # dimensions, chacun précédé de sa dimension et suivi de sa liste
68 + # (prix par variante, particularités)
69 + listings: list[Listing] = []
70 + seen: set[str] = set()
71 + for h in soup.find_all(["h3", "h4", "h5"]):
72 + name = re.sub(r"\s+", " ", h.get_text(" ", strip=True)).strip()
73 + if not re.match(r"^(Studio|Loft)", name) or len(name) > 40:
74 + continue
75 + sid = _slug(name)
76 + if sid in seen:
77 + continue
78 + seen.add(sid)
79 +
80 + dim_el = h.find_previous(string=re.compile(r"\d+\s*'"))
81 + dimension = re.sub(r"\s+", " ", str(dim_el)).strip() if dim_el else ""
82 +
83 + # toutes les puces entre ce titre de type et le suivant : prix par
84 + # variante (étage / demi-sous-sol) + particularités
85 + bullets: list[str] = []
86 + for el in h.find_all_next():
87 + if el.name in ("h3", "h4", "h5") and re.match(
88 + r"^(Studio|Loft|Façade|Galerie|Localisation)",
89 + el.get_text(" ", strip=True)):
90 + break
91 + if el.name == "li" or (el.name == "p" and
92 + "►" in el.get_text()):
93 + t = re.sub(r"\s+", " ", el.get_text(" ", strip=True))
94 + t = t.replace("►", " ").strip()
95 + t = re.sub(r"\s+", " ", t)
96 + if t and t not in bullets:
97 + bullets.append(t)
98 +
99 + # prix : « $855 /$825 » (étage) et « $810 » (demi-sous-sol) ->
100 + # le plus bas des variantes du type
101 + price_lines = [b for b in bullets if "$" in b]
102 + price_label = " / ".join(price_lines)[:80]
103 + amounts = [int(a) for a in _AMOUNT_RE.findall(" ".join(price_lines))]
104 + price = float(min(amounts)) if amounts else None
105 +
106 + # disponibilité : seulement si écrite (ex. Loft « Disponibilité à
107 + # partir de janvier 2026 »)
108 + availability = ""
109 + for b in bullets:
110 + m = re.search(r"Disponibilit[eé].*$", b)
111 + if m:
112 + availability = m.group(0).strip()
113 + break
114 +
115 + desc_parts = [f"Dimensions : {dimension}"] if dimension else []
116 + desc_parts += [b for b in bullets if b]
117 + amenities = [f"Dimensions : {dimension}"] if dimension else []
118 + amenities += common[:12]
119 +
120 + listings.append(Listing(
121 + source=self.source_id,
122 + external_id=sid,
123 + url=f"{BASE}/",
124 + title=f"Résidences Le Lauréat — {name} (étudiant tout inclus)",
125 + address=ADDRESS,
126 + sector="",
127 + city="Sherbrooke",
128 + unit_type="Loft" if name.lower().startswith("loft") else "Studio",
129 + price=price,
130 + price_label=price_label,
131 + availability=availability,
132 + description=" | ".join(desc_parts)[:1000],
133 + amenities=amenities,
134 + images=gallery[:12],
135 + ))
136 + return listings
added louka/connectors/matinale.py +160 −0
Large diff (160 lines) is not loaded by default to keep the page fast.Load diff
added louka/connectors/montagnais.py +130 −0
Large diff (130 lines) is not loaded by default to keep the page fast.Load diff
added louka/connectors/morin.py +223 −0
Large diff (223 lines) is not loaded by default to keep the page fast.Load diff
added louka/connectors/siagi.py +105 −0
Large diff (105 lines) is not loaded by default to keep the page fast.Load diff
added louka/connectors/uptimo.py +189 −0
Large diff (189 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/agence_sherbrooke.md +27 −0
Large diff (27 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/alouer_sherbrooke.md +35 −0
Large diff (35 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/ascensio.md +32 −0
Large diff (32 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/bestlife.md +35 −0
Large diff (35 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/dynamic.md +45 −0
Large diff (45 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/floria.md +32 −0
Large diff (32 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/gestimmo_estrie.md +24 −0
Large diff (24 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/immeubles_db.md +35 −0
Large diff (35 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/labonte.md +37 −0
Large diff (37 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/lelaureat.md +33 −0
Large diff (33 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/matinale.md +38 −0
Large diff (38 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/montagnais.md +36 −0
Large diff (36 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/morin.md +33 −0
Large diff (33 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/siagi.md +30 −0
Large diff (30 lines) is not loaded by default to keep the page fast.Load diff
added reports/connectors/uptimo.md +36 −0
Large diff (36 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/agence_sherbrooke.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/alouer_sherbrooke.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/ascensio.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/bestlife.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/dynamic.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/floria.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/gestimmo_estrie.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/immeubles_db.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/labonte.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/lelaureat.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/matinale.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/montagnais.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/morin.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/siagi.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added reports/sources-entries/uptimo.json +10 −0
Large diff (10 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/060fe16ec6a569680f3d.html +1248 −0
Large diff (1,249 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/191e9e596b9c4934c025.html +1397 −0
Large diff (1,398 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/1d9d442f51056162f0d0.html +1393 −0
Large diff (1,394 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/2261c4fe67ca9cd614da.html +1326 −0
Large diff (1,327 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/3691963c5af4e2f2ee59.html +1342 −0
Large diff (1,343 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/3b08a68a2f08f5d2337c.html +1337 −0
Large diff (1,338 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/4e6dd07b6211eb816573.html +1244 −0
Large diff (1,245 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/5e6748f851e801ee5f03.html +1236 −0
Large diff (1,237 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/76d7b9989a3b2bf1f60c.html +1396 −0
Large diff (1,397 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/81c1ee29c772da08a271.html +1424 −0
Large diff (1,425 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/8a145c6b4feb0c2b4ccb.html +1357 −0
Large diff (1,358 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/901061bec7974876dfe4.html +1411 −0
Large diff (1,412 lines) is not loaded by default to keep the page fast.Load diff
added tests/fixtures/agence_sherbrooke/99cbdb32cffba9f712e5.html +871 −0
Large diff (871 lines) is not loaded by default to keep the page fast.Load diff

Diff truncated — file too large.

Menu

Theme
↑↓ navigate ↵ open esc close / or ⌘K anywhere