"""
Render the metrics dict into a self-contained, A TIME-branded HTML report.
No external JS/CDN (only the Inter web font). All charts are inline SVG /
CSS so the file prints cleanly and emails/opens anywhere.
"""
import html
import json
import config
C = config.BRAND
_LOGO_SVG = """"""
def _rgb(hexcolor):
h = hexcolor.lstrip("#")
return ",".join(str(int(h[i:i + 2], 16)) for i in (0, 2, 4))
def fmt(n):
try:
return f"{int(round(float(n))):,}"
except (TypeError, ValueError):
return str(n)
def fmt1(n):
"""One-decimal formatter for small hour figures — fmt()'s int rounding
turns e.g. 0.3h into '0h', which reads as no time at all on the PDF."""
try:
return f"{float(n):.1f}"
except (TypeError, ValueError):
return str(n)
def esc(s):
return html.escape(str(s))
# ---------------------------------------------------------------------------
# Small chart primitives (inline SVG)
# ---------------------------------------------------------------------------
def _grouped_month_chart(monthly):
"""Answered vs missed grouped bars per month, with answer-rate line."""
if not monthly:
return ""
w, h = 840, 260
pad_l, pad_b, pad_t = 38, 34, 14
n = len(monthly)
gw = (w - pad_l - 8) / n
maxv = max(max(m["inbound_answered"], m["inbound_missed"]) for m in monthly) or 1
plot_h = h - pad_b - pad_t
def y(v):
return pad_t + plot_h * (1 - v / maxv)
bars, line_pts, labels = [], [], []
bw = gw * 0.30
for i, m in enumerate(monthly):
cx = pad_l + gw * i + gw / 2
ax = cx - bw - 1
mx = cx + 1
bars.append(
f''
f''
)
line_pts.append(f"{cx:.1f},{pad_t + plot_h*(1-m['answer_rate']/100):.1f}")
labels.append(
f'{esc(m["month"][5:])}'
)
# answer-rate polyline (0..100 scaled to plot)
line = (f'')
dots = "".join(f'' for p in line_pts)
gridlines = ""
for frac in (0, 0.5, 1):
gv = maxv * (1 - frac)
yy = pad_t + plot_h * frac
gridlines += (f''
f'{fmt(gv)}')
return (f'')
def _hour_chart(hourly):
w, h = 840, 170
pad_l, pad_b, pad_t = 30, 26, 10
maxv = max(hourly) or 1
gw = (w - pad_l - 6) / 24
plot_h = h - pad_b - pad_t
bars, labels = [], []
for hr, v in enumerate(hourly):
x = pad_l + gw * hr + gw * 0.12
bh = plot_h * v / maxv
# shade after-hours bars orange-ish
after = hr < config.BUSINESS_START_HOUR or hr >= config.BUSINESS_END_HOUR
color = C["gold"] if after else C["purple_med"]
bars.append(f'')
if hr % 3 == 0:
labels.append(f'{hr}:00')
return (f'')
def _dow_bars(dow):
names = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
maxv = max(dow) or 1
rows = ""
for i, v in enumerate(dow):
pct = 100 * v / maxv
rows += (f'
{names[i]}
'
f'
'
f'
{fmt(v)}
')
return rows
def _heatmap(heat):
"""7x24 grid; cell alpha scales to volume. Sat row reads near-empty (Shabbos)."""
names = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
maxv = max(max(r) for r in heat) or 1
cells = ""
# hour header
head = ''
for hr in range(24):
lab = f"{hr}" if hr % 2 == 0 else ""
head += f'
{lab}
'
cells += head
for d in range(7):
cells += f'
{names[d]}
'
for hr in range(24):
v = heat[d][hr]
a = 0.06 + 0.94 * (v / maxv) if v else 0.0
bg = f"rgba({_rgb(C['purple_deep'])},{a:.3f})" if v else C["bg"]
cells += f''
return f'
{cells}
'
# ---------------------------------------------------------------------------
# Sections
# ---------------------------------------------------------------------------
def _hero(s):
cells = [
(fmt(s["inbound_answered"]), "Inbound calls answered",
f'{s["answer_rate"]}% of attempts answered live', ""),
(f'{fmt(s["talk_hours_inbound"])} hrs', "On the phone with callers",
f'inbound talk time ({fmt(s["talk_minutes_inbound"])} minutes)', ""),
(fmt(s["unique_callers"]), "Unique people who called", f'{s["reach_rate"]}% reached a live person', ""),
(fmt(s["total_calls"]), "Overall interactions (in + out)",
f'{fmt(s["inbound_attempts"])} in · {fmt(s["outbound"])} out', ""),
(fmt(s["outbound"]), "Outbound follow-up calls",
f'staff calling families back · {fmt(s["talk_hours_outbound"])} hrs of talk time', "orange"),
(fmt(s["overnight_count"]), "Inbound calls overnight (10p–6a)",
f'{s["overnight_pct"]}% of inbound · {s["after_hours_pct"]}% outside 8a–7p', "orange"),
]
out = '
'
for num, label, cap, cls in cells:
out += (f'
{num}
'
f'
{label}
{esc(cap)}
')
return out + "
"
def _division_totals_table(rows):
"""Quick-glance Total In (=inbound attempts) / Total Out / Grand Total per division."""
body = ""
for r in rows:
body += (f'
{esc(r["division"])}
'
f'
{fmt(r["inbound_attempts"])}
'
f'
{fmt(r["outbound"])}
'
f'
{fmt(r["total"])}
')
return (
f'
Totals by division
'
f'
'
f'
Division
Total In
'
f'
Total Out
Grand Total
'
f'
{body}
')
def _division_section(rows):
"""Two tables: inbound (routing columns sum to attempts) and outbound."""
body = ""
for r in rows:
body += (f'
{esc(r["division"])}
'
f'
{fmt(r["inbound_answered"])}
'
f'
{fmt(r["inbound_missed"])}
'
f'
{fmt(r["inbound_attempts"])}
'
f'
{r["answer_rate"]}%
'
f'
{fmt(r["talk_hours_in"])}
'
f'
{fmt(r["unique_callers"])}
'
f'
{fmt(r["voicemail"])}
'
f'
{fmt(r["queue"])}
'
f'
{fmt(r["direct"])}
'
f'
{fmt(r["dept"])}
')
inbound_tbl = (
f'
Inbound
'
f'
'
f'
Division
Answered
Missed
'
f'
Attempts
Answer %
'
f'
Talk hrs
Callers
'
f'
Voicemail
'
f'
Queue
Direct
Dept
'
f'
{body}
'
f'
Queue, Direct, and Dept show how each inbound attempt was '
f'matched to its division (routing queue, staff extension, or the CDR department '
f'label) — the three always add up to the attempts column.
')
out_rows = sorted([r for r in rows if r["outbound"]],
key=lambda r: r["outbound"], reverse=True)
if not out_rows:
return inbound_tbl
obody = ""
for r in out_rows:
obody += (f'
{esc(r["division"])}
'
f'
{fmt(r["outbound"])}
'
f'
{fmt(r["talk_hours_out"])}
')
outbound_tbl = (
f'
Outbound (staff follow-up calls)
'
f'
'
f'
Division
Calls
Talk hrs
'
f'
{obody}
')
return inbound_tbl + outbound_tbl
def _cm_section(people, limit=14):
if not people:
return ""
maxv = max(p["total"] for p in people[:limit]) or 1
rows = ""
for p in people[:limit]:
pct = 100 * p["total"] / maxv
rows += (f'
{esc(p["name"])}
'
f'
'
f'
{fmt(p["inbound_answered"])} answered · '
f'{p["answer_rate"]}% · {fmt1(p.get("talk_hours_in", p["talk_hours"]))}h in / '
f'{fmt1(p.get("talk_hours_out", 0))}h out
')
return f'
{rows}
'
def _regional_section(regional, limit=10):
maxv = max(r["calls"] for r in regional[:limit]) or 1
rows = ""
for r in regional[:limit]:
pct = 100 * r["calls"] / maxv
rows += (f'
{esc(r["region"])}
'
f'
'
f'
{fmt(r["calls"])}
')
return rows
def _area_table(area_codes, limit=15):
body = ""
for a in area_codes[:limit]:
body += (f'
{esc(a["area_code"])}
'
f'
{esc(a["region"]) or "—"}
'
f'
{fmt(a["calls"])}
'
f'
{fmt(a["unique_callers"])}
')
return (f'
Area code
Region
'
f'
Inbound calls
Unique callers
'
f'
{body}
')
def _region_section(reg):
s = reg["summary"]
meta = reg["meta"]
accent = meta.get("accent") or C["orange"]
name = meta["display"]
sn = meta["key"][:3].upper()
codes_join = " and ".join(a["area_code"] for a in reg["area_codes"])
split = (
f'
'
f'
{fmt(s["inbound_attempts"])}
'
f'
inbound calls from {esc(name)} '
f'({s["answer_rate"]}% answered live)
'
f'
{fmt(s["unique_callers"])}
'
f'
unique {esc(name)}-area callers reached out '
f'— {s["reach_rate"]}% connected with a person
'
f'
{fmt(s["talk_hours"])} hrs
'
f'
of phone support to {esc(name)} families '
f'({fmt(s["talk_minutes"])} minutes)
'
f'
'
)
ac_body = ""
for a in reg["area_codes"]:
ac_body += (f'
{esc(a["area_code"])}
'
f'
{esc(a["label"])}
'
f'
{fmt(a["calls"])}
'
f'
{fmt(a["answered"])}
'
f'
{fmt(a["unique_callers"])}
')
ac = (f'
Area code
Coverage
'
f'
Inbound
Answered
'
f'
Callers
{ac_body}
')
div_body = ""
for r in reg["by_division"]:
if r["inbound_attempts"] == 0:
continue
div_body += (f'
{esc(r["division"])}
'
f'
{fmt(r["inbound_answered"])}
'
f'
{fmt(r["inbound_missed"])}
'
f'
{fmt(r["unique_callers"])}
'
f'
{fmt(r["talk_hours"])}
')
divtbl = (f'
Division
Answered
'
f'
Missed
Callers
'
f'
Talk hrs
{div_body}
')
note = (f'
{esc(meta["excluded_note"])}
'
if meta.get("excluded_note") else "")
return (
f''
f'
{sn}'
f'{esc(name)} — a closer look
'
f'
'
f'For our {esc(name)}-area supporters: here is exactly how A TIME showed up for '
f'families across {esc(meta["msa_name"])} this year. Area codes {esc(codes_join)} '
f'cover {esc(meta.get("counties",""))}.
'
f'{split}'
f'
By area code
{ac}'
f'
Which divisions {esc(name)} families reached
{divtbl}'
f'{note}'
f''
)
def _talking_points(m, region_key=None):
s = m["summary"]
period = m["meta"].get("period_label") or m["meta"]["period_end"][:4]
points = [
f'A TIME answered {fmt(s["inbound_answered"])} calls live in {esc(period)} and '
f'spent {fmt(s["talk_hours"])} hours — the equivalent of '
f'{fmt(s["talk_hours"]/24)} full days — on the phone with families '
f'({fmt(s["talk_hours_inbound"])} hrs with inbound callers, '
f'{fmt(s["talk_hours_outbound"])} hrs of outbound follow-up).',
f'{fmt(s["unique_callers"])} different people reached out across '
f'{len(m["by_division"])} reporting divisions; {s["reach_rate"]}% '
f'connected with a real person.',
f'{s["overnight_pct"]}% of inbound calls came overnight (10pm–6am) and '
f'{s["after_hours_pct"]}% outside business hours — the helplines are '
f'there when families have nowhere else to turn.',
f'When no one could pick up, {fmt(s["voicemail_count"])} callers were able to '
f'leave a voicemail so their call was never simply lost.',
]
reg = m["regions"].get(region_key) if region_key else None
if reg:
c = reg["summary"]
name = reg["meta"]["display"]
points.append(
f'{esc(name)}-area families placed {fmt(c["inbound_attempts"])} calls and '
f'received {fmt(c["talk_hours"])} hours of dedicated phone support.')
return "".join(f'
{p}
' for p in points)
def _methodology(m):
v = m["validation"]
return (
'
'
'
Data source
'
f'
Every figure is computed from {fmt(v["total_records"])} call detail records (CDRs) pulled '
'directly from the NetSapiens platform API (v2 /domains/ATIME/cdrs) for the '
f'reporting period {esc(m["meta"]["period_start"])} to {esc(m["meta"]["period_end"])}. '
'Records are pulled in pages of 100 to preserve the full 99-field record (larger page sizes '
'silently strip caller-ID and department fields).
'
'
How calls are assigned to a Reporting Division
'
'
Every department is mapped to exactly one Reporting Division by an authoritative '
'department → division matrix, so each user (including anyone added later) '
'inherits a division through their department. Calls are matched in priority order: (1) the '
'call’s queue / auto-attendant / bridge extension, (2) the direct user extension and its '
'department, (3) the raw CDR department text — all through the same matrix. This assignment '
'agrees with the CDR’s own department labels '
f'{v["classification_agreement_pct"]}% of the '
f'time ({fmt(v["classification_disagreements"])} of {fmt(v["classification_compared"])} compared). '
'Internal calls and the main auto-attendant IVR greeting leg '
f'(ext 998, {fmt(v["main_aa_998_legs"])} legs) are excluded from division metrics; '
f'{v["unmapped_pct"]}% of all records remain unmapped and are excluded to avoid double-counting.
'
'
Voicemail detection
'
'
A call is counted as reaching voicemail when its terminating URI contains VMail '
'or its match URI contains record-vmail. Voicemails occur on unanswered (missed) '
'inbound calls.
'
'
Caller geography
'
'
Caller phone numbers are extracted from the originating SIP URI '
'(call-orig-from-uri), which yields a usable 10-digit number for '
f'{v["phone_extracted_pct_inbound"]}% of inbound calls. The area code is the '
'first three digits. The Cleveland–Elyria metro is defined as area codes 216 and 440; '
'Akron–Canton (330 / 234) is a separate MSA and is excluded.
'
'
Metric definitions
'
'
Answer rate = answered ÷ (answered + missed). '
'Reach rate = unique callers who reached a live person at least once ÷ '
'all unique callers. Talk time uses call-talking-duration-seconds '
'(connected time only, not ring time), reported separately for inbound and outbound calls. '
'Queue / Direct / Dept counts cover inbound attempts only and describe how each '
'attempt was matched to its division; they sum to the attempts column. '
'Hour-of-day and day-of-week are in US/Eastern.
'
'
Known limitations
'
'
A share of calls are classified from the CDR department text rather than a '
'direct extension match (the handling extension is not always recorded on every call leg); these '
'agree with the extension-based logic where both exist. A small number of callers place calls '
'from numbers that cannot be parsed (~3% of inbound) and are excluded from geography only.
'
# ---------------------------------------------------------------------------
# Top level
# ---------------------------------------------------------------------------
def render(m, region_key=None):
"""region_key=None renders the generic org-wide report (no regional section)."""
s = m["summary"]
meta = m["meta"]
year = meta["period_end"][:4]
period_label = meta.get("period_label") or year
region = m["regions"].get(region_key) if region_key else None
rname = region["meta"]["display"] if region else ""
title_region = f' · {esc(rname)}' if rname else ""
eyebrow_tail = f' · Prepared for {esc(rname)} supporters' if rname else ""
lede_tail = f' — including those across {esc(rname)}' if rname else ""
parts = []
parts.append(f''
f''
f'{esc(meta["org_name"])} · Call Activity Report{title_region} · {esc(period_label)}'
f''
f''
f'
{esc(meta["period_start"])} – {esc(meta["period_end"])} '
f'({esc(period_label)}) · All reporting divisions · Prepared for A TIME by PressONE
'
f'
Behind every number on this page is a person who picked up the phone, and a '
f'family who needed someone on the other end. In {esc(period_label)}, A TIME’s helplines and programs '
f'answered {fmt(s["inbound_answered"])} calls and spent {fmt(s["talk_hours"])} hours listening, '
f'guiding, and walking alongside the families who reached out{lede_tail}.
'
# monthly trend — only when the period actually spans multiple months
# (a single-month report has nothing to trend)
if len(m["monthly"]) > 1:
parts.append(_h2("The year, month by month"))
parts.append(_legend([("Answered live", C["purple_deep"]), ("Missed", C["orange"]),
("Answer rate", C["gold"])]))
parts.append(f'
{_grouped_month_chart(m["monthly"])}'
f'
Inbound calls answered vs. missed each month, with the '
f'live-answer rate overlaid.
')
# divisions
parts.append(_h2("Call activity by Reporting Division"))
parts.append('
Every A TIME department rolls up to a Reporting Division — the nine '
'classic helplines plus the organization’s other programs — each with its own '
'callers, rhythms, and specialists. Inbound calls (families reaching out) and outbound '
'calls (staff following up) are shown separately.
')
parts.append(_division_totals_table(m["by_division"]))
parts.append(_division_section(m["by_division"]))
# MHL case managers
parts.append(_h2("The Medical Helpline team"))
parts.append('
The Medical Helpline (MHL) is A TIME’s busiest division. Here is the '
'call volume carried by each case manager this year.
')
parts.append(_cm_section(m["mhl_by_person"]))
# when people call
parts.append(_h2("When families call"))
parts.append(_legend([("Business hours (8a–7p)", C["purple_med"]),
("After hours", C["gold"])]))
parts.append(f'
{_hour_chart(m["hourly"])}'
f'
Inbound calls by hour of day (US/Eastern). '
f'{s["after_hours_pct"]}% arrive outside business hours.
')
parts.append('
By day of week
')
parts.append("".join(_dow_bars(m["dow"])))
# heatmap
parts.append(_h2("A week in the life"))
parts.append('
Inbound call volume by day and hour. The quiet Saturday band reflects Shabbos; '
'the helplines come back to life Saturday night.
')
parts.append(f'
{_heatmap(m["heatmap"])}'
f'
Darker cells = more calls. Each cell is one hour.
')
# geography
parts.append(_h2("Where callers reach out from"))
parts.append('
Inbound calls by region, based on caller area code.
')
parts.append(_area_table(m["geo"]["area_codes"]))
# 07 regional focus (omitted in the generic report)
if region:
parts.append(_region_section(region))
# talking points
parts.append(_h2("What this means for the families we serve"))
parts.append(_talking_points(m, region_key))
# methodology
parts.append(_h2("How these numbers were produced"))
parts.append(_methodology(m))
# footer
parts.append(
f''
)
parts.append('
')
return "".join(parts)
if __name__ == "__main__":
import sys
src = sys.argv[1] if len(sys.argv) > 1 else "output/metrics_2025.json"
out = sys.argv[2] if len(sys.argv) > 2 else "output/ATIME_Report.html"
region_key = sys.argv[3] if len(sys.argv) > 3 else "cleveland"
with open(src) as f:
m = json.load(f)
html_str = render(m, region_key)
with open(out, "w") as f:
f.write(html_str)
print(f"wrote {out} ({len(html_str):,} bytes)")