Données sur les refuges de Toronto mises à jour quotidiennement

Réplication indépendante des tableaux de bord, validation des données sources et reddition de comptes

BonQuery reconstruit indépendamment les tableaux de bord des refuges de Toronto à partir des données ouvertes, met à jour quotidiennement l’occupation et la capacité et publie des données probantes sur la réponse au froid.

Auteur(-trice)

Miriam Marling

Modifié

12 août 2026

daily_occ    = FileAttachment("data/daily_occupancy.json").json()
bt_data      = FileAttachment("data/city_bridging_triage.json").json()
city_table   = FileAttachment("data/city_daily_table.json").json()
seasonRug    = FileAttachment("data/season_rug.csv").csv().then(rows =>
  rows.map(d => ({ min_temp: +d.min_temp, winter_season: d.winter_season }))
)
binnedSC     = FileAttachment("data/cold_response_binned_by_winter_sc.csv").csv().then(rows =>
  rows.map(d => ({
    min_temp_bin:  +d.min_temp_bin,
    winter_season: d.winter_season,
    mean_unplaced: +d.mean_unplaced,
    n:             +d.n
  }))
)

// La date la plus récente que le tableau ci-dessous peut afficher, qui un jour
// de recours provient de la page Web de la Ville plutôt que des données
// ouvertes. La carte dit « disponibles ici » : elle suit donc l'affichage.
homeLatestDate = latestDate
homeLatestLabel = {
  const [year, month, day] = homeLatestDate.split("-").map(Number)
  return new Date(year, month - 1, day).toLocaleDateString("fr-CA", {
    year: "numeric", month: "long", day: "numeric"
  })
}

BonQuery reconstruit les tableaux de bord publics des refuges de Toronto à partir des sources publiques de la Ville. Nous montrons combien de places étaient utilisées, inoccupées ou indisponibles dans l’instantané de 4 h, comment la demande évolue et quand des personnes qui ont besoin d’un endroit sûr restent sans refuge.

Ces sources ne montrent pas toutes les personnes qui ont besoin d’un endroit sûr ni toutes les formes d’itinérance. Voir qui est compté, qui manque et pourquoi BonQuery emploie plusieurs termes →

Le français vous semble-t-il naturel?

J’ai utilisé un grand modèle de langage (LLM) pour traduire le site anglais en français, puis j’ai relu la traduction moi-même. Mon français est de niveau intermédiaire. Je cherche donc des personnes dont le français est la langue maternelle, surtout des francophones du Canada, qui pourraient vérifier si le texte semble naturel aux francophones d’ici.

La page d’accueil est ma priorité. Toute relecture, même partielle, est la bienvenue. Je créditerai chaque personne pour la partie qu’elle aura révisée ou relue.

Aider à relire le français →

html`<div class="bq-home-status" role="status">
  <span class="bq-status-dot" aria-hidden="true"></span>
  <span><strong>Mis à jour chaque jour.</strong> Dernières données publiées par la Ville sur les refuges présentées ici : ${homeLatestLabel}. <strong>Il ne s'agit pas de la disponibilité des places en temps réel.</strong></span>
</div>`

Commencez par votre question

COMBIEN DE PERSONNES ONT ÉTÉ HÉBERGÉES? DERNIER INSTANTANÉ DE LA VILLE

Lits et places

Consultez les dernières données de la Ville sur l'utilisation et la capacité des refuges, puis parcourez chaque journée publiée depuis janvier 2021.

Voir les données quotidiennes

COMBIEN DE PERSONNES ONT BESOIN D'UN REFUGE? DERNIÈRES DONNÉES PUBLIÉES

Portrait mensuel

Consultez le nombre actuel de personnes en situation d'itinérance active, les entrées, les sorties vers un logement et les groupes desservis. Choisissez tout mois depuis 2018.

Ouvrir le portrait

COMMENT EN SOMMES-NOUS ARRIVÉS LÀ? DERNIÈRES DONNÉES PUBLIÉES

Tendances historiques

Explorez l'évolution pluriannuelle de l'itinérance active et chronique, des sorties vers un logement et des groupes desservis.

Explorer les tendances

COMBIEN D'APPELS ONT ÉTÉ TRAITÉS? DERNIÈRES DONNÉES PUBLIÉES

Demandes d'orientation en refuge

Voyez la moyenne quotidienne des appels traités, les orientations vers une place et les personnes seules ou les couples qui ont appelé et étaient encore sans place à 4 h.

Voir les données sur les appels

LE RÉSEAU S'AMÉLIORE-T-IL? DERNIÈRES DONNÉES PUBLIÉES

Comparaison depuis le début de l'année

Comparez les entrées cumulatives et les sorties vers un logement cette année avec la même période des années précédentes.

Comparer les années

Chaque jour

Nous reconstruisons les chiffres d’occupation et de capacité à partir des données ouvertes de Toronto et signalons les places financées qui sont hors service.

Chaque mois

Nous mettons à jour les tendances des flux du réseau et de l’Admission centrale lorsque la Ville publie de nouvelles données.

Chaque hiver

Nous vérifions si la réponse au froid laisse des personnes sans place lorsque l’exposition peut causer des préjudices graves.

Voir l’occupation et la capacité quotidiennes

Examiner la demande à l’Admission centrale

Lire les données probantes sur le froid

Consulter les méthodes et les données sources

Constatations sur le froid

Un endroit chaud avant que le froid ne cause des blessures

96 % des nuits à −5 °C ou moins : De 2020-2021 à 2025-2026, au moins une personne seule ou un couple était toujours sans place à 4 h. Les personnes refusées à la porte ne sont pas comptées.

Un meilleur accès, mais des places toujours presque toutes occupées : De 2023-2024 à 2025-2026, au moins une place en accès direct était indiquée comme ouverte lors de 90 % des nuits de 0 à −5 °C, contre 40 % pendant les trois hivers précédents. Les lits et les places par temps froid étaient occupés à au moins 98 % lors de 47 % des nuits à −5 °C ou moins.

Les lésions dues au froid peuvent causer des dommages durables avant de mettre la vie en danger. Personne ne devrait subir un préjudice évitable parce qu’il lui était impossible d’entrer au chaud.

Lisez l’article complet pour consulter les sources, les méthodes et les limites. BonQuery ne peut pas offrir d’aide directe par temps froid. Pour obtenir des services vérifiés, consultez J’ai besoin d’aide maintenant.

Lire l’article sur le froid →

Voir d’où viennent les chiffres →

RESPONSABILITÉ HIVERNALE

Personnes sans place lors des nuits glaciales — six hivers de données

cs      = getComputedStyle(document.body)
refLine = cs.getPropertyValue("--bq-chart-stroke").trim()

seasonColorMap = new Map([
  ["2020-21", "#4DF884"],
  ["2021-22", "#2F9DF5"],
  ["2022-23", "#DEDD32"],
  ["2023-24", "#E63946"],
  ["2024-25", "#F65F18"],
  ["2025-26", "#900C00"]
])

viewof selectedWinters = {
  const allSeasons = [
    "2020-21","2021-22","2022-23","2023-24","2024-25","2025-26"
  ];
  const selected = new Set(allSeasons);

  if (!document.getElementById("bq-season-cb-style")) {
    const s = document.createElement("style");
    s.id = "bq-season-cb-style";
    s.textContent = `
      .bq-season-cb {
        appearance: none;
        -webkit-appearance: none;
        width: 14px;
        height: 14px;
        border-radius: 2px;
        margin: 0;
        border: 1.5px solid #888;
        cursor: pointer;
        display: inline-flex;
        align-items: center;
        justify-content: center;
        flex-shrink: 0;
        background: transparent;
      }
      .bq-season-cb:checked {
        background-color: var(--season-color);
        border-color: var(--season-color);
      }
      .bq-season-cb:checked::after {
        content: "✓";
        color: #fff;
        font-size: 10px;
        font-weight: 700;
        line-height: 1;
      }
      .bq-season-cb:hover {
        transform: scale(1.15);
        box-shadow: 0 0 0 2px rgba(0,0,0,0.15);
      }
      .bq-season-lbl {
        display: inline-flex;
        align-items: center;
        gap: 8px;
        cursor: pointer;
        user-select: none;
      }
    `;
    document.head.appendChild(s);
  }

  const root = document.createElement("div");
  root.style.cssText = "font-family:var(--sans-serif,sans-serif);font-size:13.5px;";

  const labelEl = document.createElement("div");
  labelEl.textContent = "Saisons affichées";
  labelEl.style.cssText = "font-weight:600;margin-bottom:3px;";

  const hint = document.createElement("div");
  hint.textContent = "Cliquez sur une saison pour l'afficher ou la masquer";
  hint.style.cssText =
    "font-size:11.5px;font-weight:400;color:var(--bq-fg-faint);margin-bottom:6px;";

  const row = document.createElement("div");
  row.style.cssText =
    "display:flex;flex-wrap:wrap;gap:6px 20px;align-items:center;";

  for (const season of allSeasons) {
    const color = seasonColorMap.get(season);

    const cb = document.createElement("input");
    cb.type = "checkbox"; cb.value = season; cb.checked = true;
    cb.className = "bq-season-cb";
    cb.style.setProperty("--season-color", color);

    const txt = document.createElement("span");
    txt.textContent = season;

    const lbl = document.createElement("label");
    lbl.className = "bq-season-lbl";
    lbl.append(cb, txt);
    row.append(lbl);

    cb.addEventListener("change", () => {
      if (cb.checked) selected.add(season); else selected.delete(season);
      root.value = [...selected];
      root.dispatchEvent(new Event("input"));
    });
  }

  root.append(labelEl, hint, row);
  root.value = allSeasons;
  return root;
}

Note

Lecture du graphique. Le graphique présente des données issues de jusqu’à six saisons froides (du 15 novembre au 15 avril), codées par couleur selon l’année hivernale. Les lignes verticales en arrière-plan font office de tapis de température — chaque ligne marque la température minimale nocturne enregistrée pour une nuit donnée, colorée selon sa saison. Là où ces lignes se concentrent, les données sont abondantes ; là où elles s’amenuisent (en dessous d’environ −15 °C), les nuits individuelles ont plus de poids. Utilisez les cases à cocher ci-dessus pour afficher ou masquer les saisons individuelles.

{
  const visibleBinned = binnedSC.filter(d => scSeasons.includes(d.winter_season))
  const visibleRug    = seasonRug.filter(d => scSeasons.includes(d.winter_season))

  return Plot.plot({
    width:        720,
    height:       400,
    marginLeft:   70,
    marginRight:  20,
    marginTop:    20,
    marginBottom: 50,
    color: {
      type:   "ordinal",
      legend: true,
      label:  "Saison hivernale",
      domain: [...seasonColorMap.keys()],
      range:  [...seasonColorMap.values()]
    },
    r: { range: [2, 8] },
    x: {
      label: "Température minimale nocturne (°C)",
      labelAnchor: "center",
      reverse: true
    },
    y: {
      label: "Personnes sans place (individus seuls/couples, moyenne observée)",
      labelAnchor: "top",
      grid: true
    },
    marks: [
      Plot.tickX(visibleRug, {
        x: "min_temp",
        stroke: "winter_season",
        frameAnchor: "bottom",
        strokeOpacity: 0.35,
        strokeWidth: 1
      }),
      Plot.ruleX([0, -5, -10, -15], {
        stroke: refLine,
        strokeWidth: 1,
        strokeDasharray: "4,3"
      }),
      Plot.dot(visibleBinned, {
        x: "min_temp_bin",
        y: "mean_unplaced",
        fill: "winter_season",
        r: "n"
      }),
      Plot.tip(visibleBinned, Plot.pointer({
        x: "min_temp_bin",
        y: "mean_unplaced",
        title: d =>
          `${d.winter_season}\n` +
          `Intervalle ${d.min_temp_bin} °C  ·  ${d.n} nuits\n` +
          `Moyenne observée : ${d.mean_unplaced.toFixed(1)} personne(s) sans place`
      }))
    ]
  })
}

Figure 1 : Moyenne observée de personnes (individus seuls et couples) sans place à 4 h, par température minimale nocturne et saison froide, regroupée par intervalles de 2 °C. Les intervalles sont étiquetés par leur point médian (p. ex., le point à −3 °C couvre de −4 °C jusqu’à −2 °C exclu). Chaque point représente un intervalle de température pour un hiver ; la taille du point est proportionnelle au nombre de nuits dans cet intervalle (plus grand = davantage de nuits).

Voir l’analyse complète : Laissés dans le froid →

Tableaux de bord que nous reconstruisons et vérifions

BonQuery reproduit indépendamment les tableaux de bord de la Ville à partir des données ouvertes, les met à jour lorsque les données sources sont publiées, conserve les vues historiques et rend visibles les différences entre les places financées, disponibles et occupées.

Flux mensuels du réseau de refuges

Ouvrez chaque tableau de bord directement dans votre navigateur. Ils fonctionnent mieux en plein écran sur un téléphone.

Les trois onglets ci-dessous montrent différents aspects des données mensuelles. Chaque tableau de bord contient des filtres interactifs.

Consultez le réseau de refuges pour le mois de votre choix depuis janvier 2018.

Ouvrir dans un nouvel onglet →

Comparez les chiffres cumulatifs de cette année avec la même période des années précédentes.

Ouvrir dans un nouvel onglet →

Voyez les changements sur plusieurs années dans l’itinérance et l’utilisation des refuges.

Ouvrir dans un nouvel onglet →

Occupation et capacité quotidiennes

function fmtDate(s) {
  const [y, m, d] = s.split("-").map(Number)
  return new Date(y, m - 1, d).toLocaleDateString("fr-CA", {
    year: "numeric", month: "long", day: "numeric"
  })
}

CITY_CENSUS_URL_TABLE = "https://www.toronto.ca/city-government/data-research-maps/research-reports/housing-and-homelessness-research-and-reports/shelter-census/"

// ── Deux sources, un seul tableau ─────────────────────────────────────────
// Les données ouvertes contiennent les champs détaillés et la capacité financée;
// elles ont donc priorité une fois publiées. La page Web quotidienne de la Ville sert
// uniquement de recours pour les dates que les données ouvertes n'ont pas
// encore atteintes. La priorité est établie au moment du rendu : le tableau
// revient de lui-même aux données ouvertes dès leur publication.
openDates = [...new Set(daily_occ.map(r => r.date))].sort().reverse()
latestOpenDate = openDates[0]

cityDates = Object.keys(city_table.entries ?? {}).sort().reverse()
contingencyDates = cityDates.filter(d => d > latestOpenDate)

allDates = [...new Set([...openDates, ...contingencyDates])].sort().reverse()
latestDate = allDates[0]

La version BonQuery de ce tableau ajoute deux fonctions absentes de la page de la Ville. Le sélecteur de date ci-dessous permet de consulter toute date depuis janvier 2021 jusqu’à aujourd’hui ; la page Utilisation quotidienne des refuges et services d’hébergement de nuit de la Ville n’affiche que sa date de publication la plus récente. La colonne Hors service (calculée comme financé − réel) signale les lits, chambres ou espaces temporairement indisponibles. Voir comment BonQuery combine et étiquette les deux sources de la Ville.

Occupation et capacité quotidiennes —

latestRows = daily_occ.filter(r => r.date === latestOpenDate)

function getVal(rows, key) {
  const row = rows.find(r => r.key === key)
  return row ? row.ind : null
}

validationChecks = {
  const rows = latestRows
  const checks = []

  const expectedKeys = [
    "all_shelter","room_based","singles_sector","singles_shelter","allied_summ",
    "temp_summ","iso_summ","fam_total","fam_emerg","fam_trans_r","fam_hotel",
    "sng_hotel","singles_total","emerg_total","mix_emerg","men_emerg","wom_emerg",
    "yth_emerg","trans_total","mix_trans","fam_trans_b","men_trans","wom_trans",
    "yth_trans","allied_total","respites","dropin","temp_resp","hotels","iso"
  ]
  const presentKeys = new Set(rows.map(r => r.key))
  const missingKeys = expectedKeys.filter(k => !presentKeys.has(k))
  checks.push({
    name: "Toutes les lignes attendues présentes",
    pass: missingKeys.length === 0,
    detail: missingKeys.length > 0 ? `Manquantes : ${missingKeys.join(", ")}` : null
  })

  const allShelter = getVal(rows, "all_shelter")
  const compSum = ["fam_total","sng_hotel","singles_total","allied_total","temp_resp","hotels","iso"]
    .reduce((s, k) => s + (getVal(rows, k) ?? 0), 0)
  checks.push({
    name: "Le total Tous les programmes de refuge correspond aux composantes",
    pass: allShelter === compSum,
    detail: allShelter !== compSum
      ? `all_shelter.ind=${allShelter}, somme des composantes=${compSum}, diff=${allShelter - compSum}`
      : null
  })

  const singlesTotal = getVal(rows, "singles_total")
  const emergTotal = getVal(rows, "emerg_total")
  const transTotal = getVal(rows, "trans_total")
  checks.push({
    name: "Total secteurs individus : urgence + transition = total individus",
    pass: singlesTotal === (emergTotal + transTotal),
    detail: singlesTotal !== (emergTotal + transTotal)
      ? `individus=${singlesTotal}, urgence+transition=${emergTotal + transTotal}`
      : null
  })

  const capRows = rows.filter(r => r.cap !== null && r.cap > 0)
  const arithFails = capRows.filter(r => Math.abs(r.occ + r.unocc - r.cap) > 0.5)
  checks.push({
    name: "Arithmétique interne : occupé + inoccupé = capacité réelle",
    pass: arithFails.length === 0,
    detail: arithFails.length > 0
      ? arithFails.map(r => `${r.key}: ${r.occ}+${r.unocc}≠${r.cap}`).join("; ")
      : null
  })

  return checks
}

allPass = validationChecks.every(c => c.pass)

validationBanner = {
  if (!allPass) {
    const failedChecks = validationChecks.filter(c => !c.pass)
    return html`<div style="
      background:var(--bq-warn-bg);border:1px solid var(--bq-warn-border);border-radius:4px;
      padding:8px 14px;font-size:0.88em;color:var(--bq-warn-fg);margin-bottom:12px">
      <strong>⚠ Problème de validation détecté pour ${fmtDate(latestOpenDate)}</strong>
      <details style="margin-top:6px">
        <summary style="cursor:pointer">Afficher les détails</summary>
        <ul style="margin:6px 0 0;padding-left:20px">
          ${failedChecks.map(c => html`<li>${c.name}${c.detail ? html` — <em>${c.detail}</em>` : ""}</li>`)}
        </ul>
      </details>
    </div>`
  }
  return html``
}

viewof selectedDate = Inputs.select(allDates, {
  label: "Date",
  format: d => fmtDate(d)
})

sourceNote = {
  if (selectedSource !== "city") {
    return html`<p class="bq-ckan-note">
      Dernière date disponible sur les données ouvertes de la Ville de
      Toronto : <strong>${fmtDate(latestOpenDate)}</strong>.
    </p>`
  }
  return html`<div class="bq-warn" style="margin:0.5rem 0 1rem;font-size:0.88em">
    <p style="margin:0">
      <strong>Utilisation temporaire de la page Web.</strong>
      Le fichier détaillé de données ouvertes va actuellement jusqu'au ${fmtDate(latestOpenDate)};
      cette date provient donc de sa <a href="${CITY_CENSUS_URL_TABLE}"
      target="_blank">page Web quotidienne</a>. La colonne « Financé mais
      indisponible » reste vide jusqu'à la publication du fichier détaillé.
    </p>
  </div>`
}

rowTemplate = new Map(
  daily_occ.filter(r => r.date === latestOpenDate).map(r => [r.key, r])
)

// La page Web de la Ville réutilise une seule ligne là où les données ouvertes
// en comptent deux; le moissonnage ne garde que la première occurrence.
cityKeyAliases = ({
  singles_shelter_total: ["singles_shelter_total", "singles_shelter"],
  allied_total:          ["allied_total", "allied_summ"],
  iso:                   ["iso", "iso_summ"]
})

// The City sometimes prints a section total with only an individuals count and
// leaves the rest of the row blank, as it did for Allied Services on Aug 6.
// Where every component row is present, rebuild the missing columns from them.
// The identity holds exactly on every date the City published both, so this
// reproduces the City's own arithmetic rather than inventing a figure.
//
// Done here and not in the scrape on purpose: audit_city_scrape.py reads
// city_daily_table.json as evidence of what the City actually published, and
// a derived value written into that archive would show up in the daily audit
// as though the City had published it.
cityTotalComponents = ({ allied_total: ["respites", "dropin"] })

function cityDerivedTotals(rows) {
  const byKey = new Map(rows.map(r => [r.key, r]))
  const out = new Map()
  for (const [total, parts] of Object.entries(cityTotalComponents)) {
    const t = byKey.get(total)
    if (!t || t.city_occ !== null) continue          // already published in full
    const ps = parts.map(k => byKey.get(k))
    if (ps.some(p => !p || p.city_occ === null || p.city_unocc === null
                       || p.city_cap === null)) continue
    const sum = f => ps.reduce((a, p) => a + p[f], 0)
    const occ = sum("city_occ"), cap = sum("city_cap")
    out.set(total, {
      city_occ:   occ,
      city_unocc: sum("city_unocc"),
      city_cap:   cap,
      city_rate:  cap > 0 ? Math.round(1000 * occ / cap) / 10 : null
    })
  }
  return out
}

function cityRowsFor(date) {
  const rows = (city_table.entries ?? {})[date]
  if (!rows) return []
  const patch = cityDerivedTotals(rows)
  return rows.flatMap(row => {
    const keys = cityKeyAliases[row.key] ?? [row.key]
    return keys.map(key => {
      const t = rowTemplate.get(key)
      return {
        date,
        key,
        label:       t ? t.label : row.label,
        indent:      t ? t.indent : 0,
        is_total:    t ? t.is_total : false,
        col_type:    t ? t.col_type : row.col_type,
        ind:         row.city_ind,
        occ:         (patch.get(row.key) ?? row).city_occ,
        unocc:       (patch.get(row.key) ?? row).city_unocc,
        cap:         (patch.get(row.key) ?? row).city_cap,
        rate:        (patch.get(row.key) ?? row).city_rate,
        cap_funding: null,     // la page Web de la Ville ne la publie pas
        source:      "city"
      }
    })
  })
}

dayRows = {
  const open = daily_occ.filter(r => r.date === selectedDate)
  if (open.length) return open.map(r => ({...r, source: "open"}))
  return cityRowsFor(selectedDate)
}

selectedSource = dayRows.length > 0 ? dayRows[0].source : "open"

function n(v) { return v !== null && v !== undefined ? v.toLocaleString("fr-CA") : "—" }
function pct(v) { return v !== null && v !== undefined ? v.toFixed(1) + " %" : "—" }

function offlineCell(r) {
  if (r.cap === null || r.cap === undefined) return `<td></td>`
  if (r.cap_funding === null || r.cap_funding === undefined) return `<td></td>`
  const offline = r.cap_funding - r.cap
  if (offline <= 0) {
    return `<td class="bq-num">${offline.toLocaleString("fr-CA")}</td>`
  }
  return `<td class="bq-num bq-danger">${offline.toLocaleString("fr-CA")}</td>`
}

function tableRow(r, col1Label) {
  const pad = (r.indent ?? 0) * 16
  const cls = r.is_total ? "bq-row-total" : "bq-row"
  const bld = r.is_total ? " bq-bold" : ""
  if (r.col_type === "summary") {
    return `<tr class="${cls}">
      <td style="padding-left:${pad}px" class="${bld}">${r.label}</td>
      <td class="bq-num${bld}">${n(r.ind)}</td>
      <td></td><td></td><td></td><td></td><td></td>
    </tr>`
  }
  return `<tr class="${cls}">
    <td style="padding-left:${pad}px" class="${bld}">${r.label}</td>
    <td class="bq-num${bld}">${n(r.ind)}</td>
    <td class="bq-num">${n(r.occ)}</td>
    <td class="bq-num">${n(r.unocc)}</td>
    <td class="bq-num">${n(r.cap)}</td>
    ${offlineCell(r)}
    <td class="bq-num">${pct(r.rate)}</td>
  </tr>`
}

function sectionHeader(label, col1, col2, col3, col4) {
  return `<tr class="bq-th">
    <td>${label}</td>
    <td class="bq-num">Personnes</td>
    <td class="bq-num">${col1}</td>
    <td class="bq-num">${col2}</td>
    <td class="bq-num">${col3}</td>
    <td class="bq-num">${col4}</td>
    <td class="bq-num">Taux d'occupation</td>
  </tr>`
}

function summaryHeader() {
  return `<tr class="bq-th">
    <td>Résumé de l'occupation</td>
    <td class="bq-num">Personnes</td>
    <td colspan="5"></td>
  </tr>`
}

dailyTable = {
  const s = (key) => dayRows.find(r => r.key === key)

  const allShelterInd = s("all_shelter") ? s("all_shelter").ind : null
  const btEntry  = bt_data && bt_data.entries ? bt_data.entries[selectedDate] : null
  const btInd    = btEntry ? btEntry.bridging_triage : null
  const btStart  = bt_data && bt_data.first_captured
    ? bt_data.first_captured
    : "la date de début de la collecte"
  const totalInd = (allShelterInd !== null && btInd !== null)
    ? allShelterInd + btInd
    : allShelterInd

  const totalAccomRow = `<tr class="bq-row-total bq-bold">
    <td>Total des personnes hébergées †</td>
    <td class="bq-num">${n(totalInd)}</td>
    <td></td><td></td><td></td><td></td><td></td>
  </tr>`
  const bridgingRow = btInd !== null
    ? `<tr class="bq-row-alt">
        <td style="padding-left:26px">Programmes de passerelle et de triage</td>
        <td class="bq-num">${n(btInd)}</td>
        <td></td><td></td><td></td><td></td><td></td>
       </tr>`
    : `<tr class="bq-row-na">
        <td style="padding-left:26px">Programmes de passerelle et de triage</td>
        <td class="bq-num" style="font-size:0.85em"
          >Non disponible pour cette date</td>
        <td></td><td></td><td></td><td></td><td></td>
       </tr>`

  const summaryKeys = ["all_shelter","room_based","singles_sector","singles_shelter","allied_summ","temp_summ","iso_summ"]
  const roomKeys    = ["fam_total","fam_emerg","fam_trans_r","fam_hotel","sng_hotel"]
  const bedKeys     = ["singles_total","emerg_total","mix_emerg","men_emerg","wom_emerg","yth_emerg",
                       "trans_total","mix_trans","fam_trans_b","men_trans","wom_trans","yth_trans"]
  const alliedKeys  = ["allied_total","respites","dropin"]

  return html`
    <div style="overflow-x:auto;margin:0 0 1rem">
    <table class="bq-table">
      ${summaryHeader()}
      ${totalAccomRow}
      ${bridgingRow}
      ${summaryKeys.map(k => s(k) ? tableRow(s(k)) : "").join("")}

      ${sectionHeader("Programmes de refuge, base chambre", "Chambres occupées", "Chambres inoccupées", "Capacité réelle (chambres)", "Chambres hors service")}
      ${roomKeys.map(k => s(k) ? tableRow(s(k)) : "").join("")}

      ${sectionHeader("Programmes de refuge, base lit", "Lits occupés", "Lits inoccupés", "Capacité réelle (lits)", "Lits hors service")}
      ${bedKeys.map(k => s(k) ? tableRow(s(k)) : "").join("")}

      ${sectionHeader("Services complémentaires", "Espaces occupés", "Espaces inoccupés", "Capacité réelle (espaces)", "Espaces hors service")}
      ${alliedKeys.map(k => s(k) ? tableRow(s(k)) : "").join("")}

      <tr class="bq-th">
        <td>Programmes temporaires, base lit/espace</td>
        <td class="bq-num">Personnes</td>
        <td class="bq-num">Lits/espaces occupés</td>
        <td class="bq-num">Inoccupés</td>
        <td class="bq-num">Capacité réelle</td>
        <td class="bq-num">Lits/espaces hors service</td>
        <td class="bq-num">Taux d'occupation</td>
      </tr>
      ${s("temp_resp") ? tableRow(s("temp_resp")) : ""}

      ${sectionHeader("Programmes temporaires, base chambre/unité", "Chambres occupées", "Chambres inoccupées", "Capacité réelle (chambres)", "Chambres hors service")}
      ${s("hotels") ? tableRow(s("hotels")) : ""}

      ${sectionHeader("Programmes d'isolement/rétablissement temporaires", "Chambres occupées", "Chambres inoccupées", "Capacité réelle (chambres)", "Chambres hors service")}
      ${s("iso") ? tableRow(s("iso")) : ""}
    </table>
    <p class="bq-footnote">
      † Total des personnes hébergées = Tous les programmes de refuge + Programmes de
      passerelle et de triage. Les chiffres des Programmes de passerelle et de triage ne
      sont pas publiés dans les données ouvertes de la Ville de Toronto (CKAN). BonQuery
      les collecte quotidiennement depuis la page du recensement des refuges de la Ville
      lorsque la Ville publie le tableau ; les données sont disponibles depuis ${btStart}.
      Les jours où la Ville n'a pas encore publié (fins de semaine, jours fériés ou
      délais de publication), la ligne Passerelle et triage affichera
      « Non disponible pour cette date » et le Total reflètera uniquement Tous les
      programmes de refuge.
    </p>
    </div>`
}

Ce tableau reproduit le rapport d’utilisation quotidienne des refuges et services d’hébergement de nuit de la Ville de Toronto à partir des données ouvertes de la Ville. Le sous-total Tous les programmes de refuge et toutes les lignes de détail sont dérivés de l’exportation des données ouvertes CKAN. Les Programmes de passerelle et de triage sont suivis dans le système opérationnel de la Ville mais ne sont pas publiés dans les données ouvertes ; BonQuery collecte ce chiffre quotidiennement depuis la page du recensement des refuges de la Ville et l’affiche lorsqu’il est disponible. Le Total des personnes hébergées égale Tous les programmes de refuge + Passerelle et triage lorsque les deux sont disponibles. La page Web et le fichier de données ouvertes peuvent être publiés selon des calendriers différents. Voir comment BonQuery combine et étiquette les deux sources.

Contient des informations sous licence Licence du gouvernement ouvert – Toronto. Source : Données ouvertes de la Ville de Toronto — Utilisation quotidienne des refuges et services d’hébergement de nuit, occupation et capacité. Agrégées par BonQuery.

Les données agrégées de BonQuery sont disponibles en téléchargement de 2021 à aujourd’hui : JSON · CSV

Demandes d’orientation en refuge

Moyenne quotidienne mensuelle des appels à la ligne d’orientation des refuges de Toronto (24 h/7 j) — appels orientés vers une place en refuge, appelants individuels sans jumelage et total des appels traités — avec contrôles de date interactifs. Reproduit et étend la page Demandes d’orientation dans les refuges de la Ville. Données provenant de deux ressources CKAN distinctes (codes de clôture des appels et file d’attente des services) ; voir la page pour des mises en garde importantes sur la combinaison des deux séries.

Demandes d’orientation en refuge →

Ouvrir dans un nouvel onglet →

Contient des informations sous licence Licence du gouvernement ouvert – Toronto. Source : Données ouvertes de la Ville de Toronto — Appels à l’Admission centrale. Analyse et graphiques par BonQuery.

BonQuery vérifie les données publiques de Toronto sur les refuges. Vous voulez savoir exactement comment nous avons obtenu les chiffres? Écrivez à Miriam.

Retour au sommet