@rubytech/create-maxy-code 0.1.60 → 0.1.61

package/payload/premium-plugins/real-agent/plugins/preval/skills/property-preval/references/render.py

@@ -2,7 +2,7 @@
 
 Substitutes <!-- REPLACE: <slot> --> placeholders in template.html with values
 derived from one inputs.json (shape: template-inputs.schema.json), drives
-Chrome headless to produce a 4-page A4 PDF, and asserts page count == 4.
+Chrome headless to produce a 5-page A4 PDF, and asserts page count == 5.
 
 Usage:
     python3 render.py inputs.json
@@ -12,10 +12,25 @@ import html, json, re, shutil, subprocess, sys
 from pathlib import Path
 
 
+M2_TO_SQFT = 10.7639
+
+
 def _money(n: int) -> str:
     return f"£{int(n):,}"
 
 
+def _range_money(low: int, high: int) -> str:
+    return f"£{int(low):,} – £{int(high):,}"
+
+
+# ---------------- helpers ----------------
+
+def _short_address(address: str) -> str:
+    """First two address tokens for the cover meta strip."""
+    parts = [p.strip() for p in address.split(",")]
+    return ", ".join(parts[:2]) if len(parts) >= 2 else address
+
+
 def _sold_comps_rows(rows: list[dict]) -> str:
     if not rows:
         return '<tr><td colspan="4" class="muted">No sold transactions in the sample.</td></tr>'
@@ -49,31 +64,6 @@ def _asking_comps_tiles(rows: list[dict]) -> str:
     return "".join(out)
 
 
-def _crime_rows(rows: list[dict]) -> str:
-    if not rows:
-        return '<div class="muted">No crime data.</div>'
-    top = sorted(rows, key=lambda r: r["count"], reverse=True)[:6]
-    cap = max((r["count"] for r in top), default=1) or 1
-    return "".join(
-        f'<div class="dist-row">'
-        f'<div class="name">{html.escape(r["category"])}</div>'
-        f'<div class="bar"><span{" class=gold" if i == 0 else ""} style="width:{int(100 * r["count"] / cap)}%"></span></div>'
-        f'<div class="pct">{r["count"]}</div>'
-        f"</div>"
-        for i, r in enumerate(top)
-    )
-
-
-def _band_rows(rows: list[dict]) -> str:
-    if not rows:
-        return '<tr><td colspan="2" class="muted">No banding data.</td></tr>'
-    return "".join(
-        f"<tr><td>Band {html.escape(r['band'])}</td>"
-        f"<td class=\"num\">{_money(r['amount'])}</td></tr>"
-        for r in rows
-    )
-
-
 def _type_dist_rows(rows: list[dict]) -> str:
     if not rows:
         return '<div class="muted">No property-type mix data.</div>'
@@ -89,7 +79,7 @@ def _type_dist_rows(rows: list[dict]) -> str:
 
 
 def _spark_svg(price_series: list[dict], psf_series: list[dict]) -> str:
-    """Two-line sparkline in a 1000x380 viewBox SVG, no external dependencies."""
+    """Two-line sparkline in a 1000x380 viewBox SVG, no external deps."""
     W, H = 1000, 380
     pad_l, pad_r, pad_t, pad_b = 70, 30, 30, 50
     iw, ih = W - pad_l - pad_r, H - pad_t - pad_b
@@ -102,9 +92,7 @@ def _spark_svg(price_series: list[dict], psf_series: list[dict]) -> str:
         if ymax == ymin:
             ymax = ymin + 1
         n = len(series)
-        pts = []
-        circles = []
-        labels = []
+        pts, circles, labels = [], [], []
         for i, p in enumerate(series):
             x = pad_l + (i * iw / max(1, n - 1))
             y = pad_t + ih - ((float(p[key]) - ymin) / (ymax - ymin)) * ih
@@ -115,8 +103,7 @@ def _spark_svg(price_series: list[dict], psf_series: list[dict]) -> str:
             )
         return (
             f'<polyline class="{css_pl}" points="{" ".join(pts)}"/>'
-            + "".join(circles)
-            + "".join(labels)
+            + "".join(circles) + "".join(labels)
         )
 
     axis = (
@@ -128,54 +115,283 @@ def _spark_svg(price_series: list[dict], psf_series: list[dict]) -> str:
     )
 
 
+def _summary_paragraphs(paras: list[str]) -> str:
+    if not paras:
+        return ""
+    out = [f'<p class="dropcap">{html.escape(paras[0])}</p>']
+    for p in paras[1:]:
+        out.append(f"<p>{html.escape(p)}</p>")
+    return "".join(out)
+
+
+def _wordmark(brand: dict, variant: str, out_dir: Path) -> str:
+    """variant ∈ {'light', 'dark'}. Mirrors property-market-report's wordmark."""
+    key = "logo_light" if variant == "light" else "logo_dark"
+    logo_path = brand.get(key)
+    if logo_path:
+        src = Path(logo_path).expanduser()
+        dest_dir = out_dir / "img"
+        dest_dir.mkdir(parents=True, exist_ok=True)
+        dest = dest_dir / src.name
+        if src.resolve() != dest.resolve():
+            shutil.copy2(src, dest)
+        rel = f"img/{src.name}"
+        height = "14mm" if variant == "light" else "9mm"
+        return f'<img src="{html.escape(rel)}" alt="{html.escape(brand["name"])}" style="height:{height};width:auto;display:block">'
+    cls = "wm light" if variant == "light" else "wm small"
+    return (
+        f'<div class="{cls}">'
+        f'<span class="wm-name">{html.escape(brand["name"])}</span>'
+        f'<span class="wm-sub">{html.escape(brand["tagline"])}</span>'
+        f"</div>"
+    )
+
+
+def _hero_asset(subject: dict, out_dir: Path) -> str:
+    """Copy subject.cover_hero into img/ and return the relative path. URLs pass through."""
+    hero = subject["cover_hero"]
+    if hero.startswith(("http://", "https://", "data:")):
+        return hero
+    src = Path(hero).expanduser()
+    if not src.exists():
+        raise FileNotFoundError(f"subject.cover_hero not found: {src}")
+    dest_dir = out_dir / "img"
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / f"hero{src.suffix.lower()}"
+    if src.resolve() != dest.resolve():
+        shutil.copy2(src, dest)
+    return f"img/{dest.name}"
+
+
+def _listing_card(p: dict, index: int, out_dir: Path) -> str:
+    addr_parts = [x.strip() for x in p["address"].split(",")]
+    addr = html.escape(addr_parts[0])
+    chips = []
+    if p.get("beds"):  chips.append(f"{p['beds']} bed")
+    if p.get("type"):  chips.append(html.escape(p["type"]))
+    chips_html = "".join(f"<span>{c}</span>" for c in chips)
+    img_src = ""
+    if p.get("image"):
+        src = Path(p["image"]).expanduser() if not str(p["image"]).startswith(("http://", "https://", "data:")) else None
+        if src and src.exists():
+            dest_dir = out_dir / "img"
+            dest_dir.mkdir(parents=True, exist_ok=True)
+            dest = dest_dir / f"agent-{index:02d}-{p['slug']}{src.suffix.lower()}"
+            if src.resolve() != dest.resolve():
+                shutil.copy2(src, dest)
+            img_src = f"img/{dest.name}"
+        elif src is None:
+            img_src = str(p["image"])
+    status = p.get("status", "")
+    badge_cls = {"Sold": "sold", "Under offer": "under"}.get(status, "")
+    photo = (
+        f'<div class="photo">'
+        f'{f"<img src=\"{html.escape(img_src)}\" alt=\"{addr}\">" if img_src else ""}'
+        f'<div class="badge {badge_cls}">{html.escape(status)}</div>'
+        f"</div>"
+    )
+    meta = (
+        f'<div class="meta">'
+        f'<div class="addr">{addr}</div>'
+        f'<div class="price">{_money(p["price"])}</div>'
+        f'<div class="kfs">{chips_html}</div>'
+        f"</div>"
+    )
+    inner = photo + meta
+    if p.get("url"):
+        return f'<a class="listing" href="{html.escape(p["url"])}" target="_blank" rel="noopener">{inner}</a>'
+    return f'<div class="listing">{inner}</div>'
+
+
+def _agent_listings_cards(rows: list[dict], out_dir: Path) -> str:
+    if not rows:
+        return '<div class="muted" style="margin-top:5mm">No recent listings supplied.</div>'
+    return "".join(_listing_card(p, i, out_dir) for i, p in enumerate(rows[:6]))
+
+
+# ---------------- valuation maths ----------------
+
+def _valuation_block(subject: dict, valuation: dict) -> str:
+    """Build the page-2 valuation panel: headline range, adjustments, final range.
+
+    Falls back to the 'requires floor area' state when subject.sqft is missing.
+    """
+    sqft = subject.get("sqft")
+    if not sqft:
+        return (
+            '<div class="val-panel"><div class="val-empty">'
+            "Estimate requires floor area.<br>"
+            "<span style=\"font-size:10pt;color:var(--text-muted)\">"
+            f"Benchmark: sold £/sqft = {_money(valuation['sold_psf'])}, "
+            f"asking £/sqft = {_money(valuation['asking_psf'])}. "
+            "Paste subject.sqft to compute the range."
+            "</span></div></div>"
+        )
+
+    low_psf  = valuation["sold_psf_low"]
+    mid_psf  = valuation["sold_psf"]
+    high_psf = valuation["sold_psf_high"]
+    ask_psf  = valuation["asking_psf"]
+
+    low_raw  = int(sqft * low_psf)
+    mid_raw  = int(sqft * mid_psf)
+    high_raw = int(sqft * high_psf)
+    ask_raw  = int(sqft * ask_psf)
+
+    rows = [
+        ('<div class="val-row headline">'
+         f'<div class="lbl">Headline range<small>{sqft:,} sqft × £{low_psf}–£{high_psf} sold £/sqft (Land Registry 70pc band)</small></div>'
+         f'<div class="num">{_range_money(low_raw, high_raw)}</div></div>'),
+        ('<div class="val-row">'
+         f'<div class="lbl">Cross-check · asking £/sqft<small>{sqft:,} sqft × £{ask_psf} mean asking £/sqft</small></div>'
+         f'<div class="num">{_money(ask_raw)}</div></div>'),
+    ]
+
+    adjustments = subject.get("adjustments") or []
+    if adjustments:
+        rows.append('<div class="val-row"><div class="lbl" style="font-family:var(--sans);font-weight:600;font-size:8pt;letter-spacing:2pt;text-transform:uppercase;color:var(--text-accent)">Adjustments</div><div class="num">&nbsp;</div></div>')
+        for adj in adjustments:
+            delta = float(adj["delta_pct"])
+            cls = "pos" if delta > 0 else ("neg" if delta < 0 else "")
+            sign = "+" if delta >= 0 else ""
+            rows.append(
+                '<div class="val-row adj">'
+                f'<div class="lbl">{html.escape(adj["label"])}</div>'
+                f'<div class="num {cls}">{sign}{delta:.1f}%</div>'
+                "</div>"
+            )
+
+    delta_sum = sum(float(a["delta_pct"]) for a in adjustments)
+    factor = 1.0 + delta_sum / 100.0
+    low_final  = int(low_raw  * factor)
+    high_final = int(high_raw * factor)
+
+    final = (
+        '<div class="val-final">'
+        f'<div class="lbl">Final indicative range</div>'
+        f'<div class="num">{_range_money(low_final, high_final)}</div>'
+        "</div>"
+    )
+
+    return '<div class="val-panel">' + "".join(rows) + "</div>" + final
+
+
+def _kpi_subject_sqft(subject: dict) -> tuple[str, str]:
+    sqft = subject.get("sqft")
+    m2 = subject.get("sqft_m2")
+    if sqft:
+        sub = f"≈ {m2:.0f} m² · from EPC register" if m2 else "Square feet (operator)"
+        return f"{int(sqft):,}", sub
+    return "—", "No EPC on file"
+
+
+def _kpi_subject_epc(subject: dict) -> tuple[str, str]:
+    current  = subject.get("epc_current")
+    potential = subject.get("epc_potential")
+    lodgement = subject.get("epc_lodgement")
+    if not current:
+        return "—", "No EPC on file"
+    sub_bits = []
+    if potential:
+        sub_bits.append(f"potential {potential}")
+    if lodgement:
+        sub_bits.append(f"lodged {lodgement}")
+    return current, " · ".join(sub_bits) or "EPC register"
+
+
+# ---------------- render ----------------
+
 def render(inputs: dict, out_dir: Path, template_path: Path | None = None) -> Path:
     template_path = template_path or (Path(__file__).parent / "template.html")
     tmpl = template_path.read_text()
 
-    v = inputs["valuation"]
-    a = inputs["area"]
-    d = inputs["demand_trend"]
-    r = d["rental"]
+    brand   = inputs["brand"]
+    subject = inputs["subject"]
+    v       = inputs["valuation"]
+    a       = inputs["area"]
+    d       = inputs["demand_trend"]
+    ms      = inputs["market_summary"]
+    r       = d["rental"]
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    subject_sqft, subject_sqft_sub = _kpi_subject_sqft(subject)
+    subject_epc,  subject_epc_sub  = _kpi_subject_epc(subject)
+
+    yoy = d.get("yoy_growth_pct")
+    if yoy is None and len(d.get("growth_series", [])) >= 2:
+        last, prev = d["growth_series"][-1]["price"], d["growth_series"][-2]["price"]
+        yoy = (last - prev) / prev * 100.0
+    yoy_str = f"{yoy:+.1f}%" if yoy is not None else "—"
+
+    psf = d.get("sales_per_month")
+    if psf is None:
+        psf = max(1, round(d["for_sale"] / 7))  # crude fallback only when not provided
 
     slots = {
+        # branding
+        "brand_name":         brand["name"],
+        "brand_tagline":      brand["tagline"],
+        "brand_primary":      brand["primary"],
+        "brand_primary_dark": brand["primary_dark"],
+        "brand_accent":       brand["accent"],
+        "brand_paper":        brand["paper"],
+        "brand_paper_banded": brand["paper_banded"],
+        "brand_rule":         brand["rule"],
+        "wordmark_light":     _wordmark(brand, "light", out_dir),
+        "wordmark_dark":      _wordmark(brand, "dark",  out_dir),
+
+        # cover + header
+        "subject_hero_path":  _hero_asset(subject, out_dir),
         "address":            inputs["address"],
+        "address_short":      _short_address(inputs["address"]),
         "postcode":           inputs["postcode"],
         "generated":          inputs["generated"],
 
-        "kpi_avg_asking":     _money(v["avg_asking"]),
-        "kpi_asking_psf":     _money(v["asking_psf"]),
-        "kpi_avg_sold":       _money(v["avg_sold"]),
-        "kpi_sold_psf":       _money(v["sold_psf"]),
-        "sold_comps_rows":    _sold_comps_rows(v.get("sold_comps", [])),
-        "asking_comps_tiles": _asking_comps_tiles(v.get("asking_comps", [])),
-
-        "area_headline":      a["headline"],
-        "kpi_crime":          a["crime_rating"],
-        "kpi_flood":          a["flood_risk"],
-        "kpi_band_d":         _money(a["council_tax_band_d"]),
-        "kpi_population":     f"{int(a['population']):,}",
-        "crime_rows":         _crime_rows(a.get("crime_breakdown", [])),
-        "band_rows":          _band_rows(a.get("council_tax_bands", [])),
-
-        "kpi_demand_rating":  d["demand_rating"],
-        "kpi_dom":            str(d["dom"]),
-        "kpi_turnover":       f"{int(d['turnover_pct'])}%",
-        "kpi_for_sale":       str(d["for_sale"]),
-        "spark_svg":          _spark_svg(d.get("growth_series", []), d.get("growth_psf_series", [])),
-
-        "rental_rating":      r["demand_rating"],
-        "rental_dom":         str(r["dom"]),
-        "rental_turnover":    f"{int(r['turnover_pct'])}%",
-        "rental_for_rent":    str(r["for_rent"]),
-
-        "type_dist_rows":     _type_dist_rows(d.get("type_dist", [])),
+        # page 2 — subject valuation
+        "kpi_subject_sqft":     subject_sqft,
+        "kpi_subject_sqft_sub": subject_sqft_sub,
+        "kpi_subject_beds":     str(subject.get("beds") or "—"),
+        "kpi_subject_epc":      subject_epc,
+        "kpi_subject_epc_sub":  subject_epc_sub,
+        "kpi_subject_type":     subject.get("type") or "—",
+        "kpi_subject_tenure":   subject.get("tenure") or "Tenure unknown",
+        "valuation_block":      _valuation_block(subject, v),
+        "subject_narrative":    subject.get("narrative") or "",
+
+        # page 3 — market context
+        "summary_headline":     ms["headline"],
+        "summary_paragraphs":   _summary_paragraphs(ms["paragraphs"]),
+        "kpi_avg_asking":       _money(v["avg_asking"]),
+        "kpi_avg_sold":         _money(v["avg_sold"]),
+        "kpi_psf":              _money(v["asking_psf"]),
+        "kpi_yoy":              yoy_str,
+        "demand_rating":        d["demand_rating"],
+        "gauge_position":       ms["demand_gauge_position"],
+        "price_growth_note":    ms["price_growth_note"],
+        "demand_note":          ms["demand_note"],
+        "spark_svg":            _spark_svg(d.get("growth_series", []), d.get("growth_psf_series", [])),
+
+        # page 4 — comparables
+        "sold_comps_rows":      _sold_comps_rows(v.get("sold_comps", [])),
+        "asking_comps_tiles":   _asking_comps_tiles(v.get("asking_comps", [])),
+
+        # page 5 — agent listings + sources
+        "agent_listings_cards": _agent_listings_cards(inputs["agent_listings"], out_dir),
     }
 
-    # Escape free-form text slots that aren't already HTML fragments.
-    text_slots = {"address", "postcode", "generated", "area_headline", "kpi_crime", "kpi_flood",
-                  "kpi_demand_rating", "rental_rating"}
+    # Escape only the plain-text slots; HTML fragments pass through untouched.
+    text_slots = {
+        "address", "address_short", "postcode", "generated",
+        "brand_name", "brand_tagline",
+        "kpi_subject_beds", "kpi_subject_epc", "kpi_subject_epc_sub",
+        "kpi_subject_sqft", "kpi_subject_sqft_sub",
+        "kpi_subject_type", "kpi_subject_tenure",
+        "summary_headline", "demand_rating",
+        "price_growth_note", "demand_note", "subject_narrative",
+    }
     for k in text_slots:
-        slots[k] = html.escape(slots[k])
+        slots[k] = html.escape(str(slots[k]))
 
     out = tmpl
     for k, val in slots.items():
@@ -187,7 +403,6 @@ def render(inputs: dict, out_dir: Path, template_path: Path | None = None) -> Pa
             "template has unfilled placeholders: " + ", ".join(sorted(set(leftovers)))
         )
 
-    out_dir.mkdir(parents=True, exist_ok=True)
     out_path = out_dir / "index.html"
     out_path.write_text(out)
     return out_path
@@ -212,11 +427,10 @@ _PAGE_OBJ_RE = re.compile(rb"/Type\s*/Page(?![sA-Za-z])")
 
 
 def _count_pages(pdf_path: Path) -> int:
-    """Prefer pdfinfo (handles compressed object streams); fall back to a
-    raw `/Type /Page` byte scan when pdfinfo is not installed. The fallback
-    is correct for current Chrome `--print-to-pdf` output (no `/ObjStm`)
-    but would silently undercount if a future Chrome switches to compressed
-    page-object streams — hence pdfinfo first when available.
+    """pdfinfo first (handles /ObjStm-compressed page-object streams), with a
+    raw /Type /Page byte scan as fallback. The fallback is correct for current
+    Chrome --print-to-pdf output but would undercount if Chrome ever switches
+    to compressed page-object streams — hence pdfinfo first when present.
     """
     pdfinfo = shutil.which("pdfinfo")
     if pdfinfo:
@@ -231,13 +445,6 @@ def _count_pages(pdf_path: Path) -> int:
 
 
 def assert_page_count(pdf_path: Path, expected: int) -> int:
-    """Assert PDF page count == expected; raise RuntimeError otherwise.
-
-    Synchronous and reliable — does not depend on Spotlight (`mdls` returns
-    `(null)` until indexing finishes, which is async). Operators can still
-    verify externally with `mdls -name kMDItemNumberOfPages <pdf>` once
-    Spotlight catches up.
-    """
     n = _count_pages(pdf_path)
     if n != expected:
         raise RuntimeError(
@@ -256,7 +463,7 @@ def main():
     base = inputs["filename_stem"]
     render(inputs, out_dir)
     pdf = render_pdf(out_dir, f"{base}.pdf")
-    pages = assert_page_count(pdf, 4)
+    pages = assert_page_count(pdf, 5)
     print(f"HTML  → {out_dir/'index.html'}")
     print(f"PDF   → {pdf} ({pages} pages)")