bobframes 0.1.0__py3-none-any.whl

bobframes/reports/cli.py

@@ -0,0 +1,99 @@
+"""CLI dispatch + path utilities + report-tail helpers."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from typing import Callable
+
+from .. import lint as _lint
+from .. import paths as _paths
+from ..manifest import now_iso  # single UTC timestamp helper (H-28); re-exported via base
+from .discovery import DropSet, discover_drops, resolve_drop_set
+
+
+def _lint_or_raise(path: str) -> None:
+    hits = _lint.lint_file(path)
+    if hits:
+        msg_lines = [f'lint blocked {path}:']
+        for lineno, label, snippet in hits:
+            msg_lines.append(f'  line {lineno} [{label}]: {snippet}')
+        raise RuntimeError('\n'.join(msg_lines))
+
+
+def ab_subdir(root: str, baseline: DropSet, compare: DropSet) -> str:
+    d = os.path.join(root, '_reports', 'ab', f'{baseline.key}_vs_{compare.key}')
+    os.makedirs(d, exist_ok=True)
+    return d
+
+
+def output_path(root: str, name: str, ab: tuple | None) -> str:
+    if ab is None:
+        d = os.path.join(root, '_reports')
+        os.makedirs(d, exist_ok=True)
+        return os.path.join(d, f'{name}.html')
+    baseline, compare = ab
+    return os.path.join(ab_subdir(root, baseline, compare), f'{name}.html')
+
+
+def crumb_depth(ab) -> int:
+    """Depth of crumb relative-path: 3 levels deep when A/B (under _reports/ab/<pair>/), 1 otherwise."""
+    return 3 if ab is not None else 1
+
+
+def rel_path_to_drop_index(out_dir: str, drop_dir: str, anchor: str | None = None) -> str:
+    """Relative path from out_dir to the per-drop browser index.html.
+
+    drop_dir is the per-drop data dir (<root>/_data/<area>/<drop>/).
+    The browser HTML lives at <root>/_reports/drill/<area>/<drop>/index.html.
+    """
+    drill_dir = _paths.drop_dir_to_drill_dir(drop_dir)
+    target = os.path.join(drill_dir, 'index.html')
+    p = os.path.relpath(target, out_dir).replace('\\', '/')
+    return p + ('#' + anchor if anchor else '')
+
+
+def rel_path_to_drop_file(out_dir: str, drop_dir: str, subpath: str) -> str:
+    """Relative path from out_dir to a file under the per-drop data dir.
+
+    drop_dir is <root>/_data/<area>/<drop>/. Used for shader_src/<id>.glsl etc.
+    """
+    if not subpath:
+        return ''
+    target = os.path.join(drop_dir, subpath)
+    return os.path.relpath(target, out_dir).replace('\\', '/')
+
+
+def write_report(out_path: str, parts) -> str:
+    """Write joined parts to out_path, lint, return out_path. Raises on lint hits."""
+    with open(out_path, 'w', encoding='utf-8') as f:
+        f.write('\n'.join(parts))
+    _lint_or_raise(out_path)
+    return out_path
+
+
+def run_report(build_fn: Callable, *, module_name: str) -> int:
+    ap = argparse.ArgumentParser(prog=f'bobframes.reports.{module_name}')
+    ap.add_argument('root', nargs='?', default='.')
+    ap.add_argument('--baseline-label', default=None)
+    ap.add_argument('--compare-label', default=None)
+    ap.add_argument('--baseline-date', default=None)
+    ap.add_argument('--compare-date', default=None)
+    args = ap.parse_args(sys.argv[1:])
+    root = os.path.abspath(args.root)
+
+    if args.baseline_label or args.compare_label:
+        baseline = resolve_drop_set(root, label=args.baseline_label,
+                                    date=args.baseline_date)
+        compare = resolve_drop_set(root, label=args.compare_label,
+                                   date=args.compare_date)
+        if not baseline or not compare:
+            print(f'A/B resolve failed: baseline={args.baseline_label}, '
+                  f'compare={args.compare_label}', file=sys.stderr)
+            return 2
+        out = build_fn(root, drops=[baseline, compare], ab=(baseline, compare))
+    else:
+        out = build_fn(root, drops=discover_drops(root), ab=None)
+    print(f'wrote {out}')
+    return 0

bobframes/reports/delta.py

@@ -0,0 +1,167 @@
+"""Comparison cells and visualization helpers."""
+
+from __future__ import annotations
+
+import html as _html
+
+from .chrome import DRAW_CLASSES, class_color_var, h
+
+
+def rank_pill(n: int) -> str:
+    cls = f'rank rank-{n}' if 1 <= n <= 3 else 'rank'
+    return f'<span class="{cls}">{n}</span>'
+
+
+def inline_bar(value, max_value, *, color_var: str | None = None) -> str:
+    """Render a 80x6 inline progress bar. Renders empty if value/max invalid."""
+    if max_value in (None, 0, 0.0):
+        return ''
+    try:
+        v = float(value or 0)
+        m = float(max_value)
+    except (TypeError, ValueError):
+        return ''
+    if m <= 0:
+        return ''
+    pct = max(0.0, min(100.0, (v / m) * 100.0))
+    style = f'width: {pct:.2f}%;'
+    if color_var:
+        style += f' background: {color_var};'
+    return f'<div class="ibar"><div style="{style}"></div></div>'
+
+
+def delta_pill(curr, prev, *, lower_is_better: bool | None = True,
+               fmt: str = '{:+,.0f}') -> str:
+    """Same logic as delta_cell but renders <span class='delta-pill'>."""
+    if curr is None and prev is None:
+        return '<span class="delta-pill flat"></span>'
+    if prev is None:
+        return '<span class="delta-pill new">new</span>'
+    if curr is None:
+        curr = 0
+    try:
+        curr_f = float(curr)
+        prev_f = float(prev)
+    except (TypeError, ValueError):
+        return '<span class="delta-pill flat"></span>'
+    diff = curr_f - prev_f
+    if diff == 0:
+        return '<span class="delta-pill flat">0</span>'
+    if lower_is_better is None:
+        cls = 'flat'
+    elif lower_is_better:
+        cls = 'pos' if diff < 0 else 'neg'
+    else:
+        cls = 'pos' if diff > 0 else 'neg'
+    text = fmt.format(diff).replace('−', '-')
+    return f'<span class="delta-pill {cls}">{_html.escape(text)}</span>'
+
+
+def delta_cell(curr, prev, *,
+               lower_is_better: bool | None = True,
+               fmt: str = '{:+,.0f}',
+               regression_threshold_pct: float | None = None) -> str:
+    """Render <td> for a per-KPI delta. ASCII signs only. CSS class encodes direction."""
+    if curr is None and prev is None:
+        return '<td class="delta flat"></td>'
+    if prev is None:
+        return '<td class="delta new">new</td>'
+    if curr is None:
+        curr = 0
+    try:
+        curr_f = float(curr)
+        prev_f = float(prev)
+    except (TypeError, ValueError):
+        return '<td class="delta flat"></td>'
+
+    diff = curr_f - prev_f
+    if diff == 0:
+        return '<td class="delta flat">0</td>'
+
+    if lower_is_better is None:
+        cls = 'flat'
+    elif lower_is_better:
+        cls = 'pos' if diff < 0 else 'neg'
+    else:
+        cls = 'pos' if diff > 0 else 'neg'
+
+    alarm = ''
+    if regression_threshold_pct is not None and prev_f != 0:
+        pct = abs(diff) / abs(prev_f) * 100.0
+        if pct > regression_threshold_pct:
+            alarm = ' alarm'
+
+    text = fmt.format(diff).replace('−', '-')
+    return f'<td class="delta {cls}{alarm}">{_html.escape(text)}</td>'
+
+
+def class_segments_bar(weights: dict, total: float | None = None) -> str:
+    if total is None:
+        total = sum(weights.values())
+    try:
+        total_f = float(total)
+    except (TypeError, ValueError):
+        total_f = 0.0
+    if total_f <= 0:
+        return '<div class="bar"></div>'
+    parts = ['<div class="bar">']
+    for cls in DRAW_CLASSES:
+        n = weights.get(cls, 0)
+        try:
+            n_f = float(n)
+        except (TypeError, ValueError):
+            n_f = 0.0
+        if n_f <= 0:
+            continue
+        pct = n_f * 100.0 / total_f
+        label = ''
+        if pct >= 8.0:
+            if isinstance(n, float) and not n.is_integer():
+                label = f'{n_f:,.2f}'
+            else:
+                label = f'{int(n_f):,}'
+        parts.append(
+            f'<div class="seg" style="width: {pct:.4f}%; background: {class_color_var(cls)};" '
+            f'title="{h(cls)}: {label or n_f}">{h(label)}</div>'
+        )
+    parts.append('</div>')
+    return ''.join(parts)
+
+
+def sparkline_svg(values: list, w: int = 60, h_: int = 14) -> str:
+    """Inline SVG polyline. None values render as segment breaks (multi-polyline)."""
+    if not values or all(v is None for v in values):
+        return ''
+    finite = [float(v) for v in values if v is not None]
+    if not finite:
+        return ''
+    lo = min(finite)
+    hi = max(finite)
+    span = hi - lo if hi != lo else 1.0
+    n = len(values)
+    if n < 2:
+        return ''
+    step = w / (n - 1)
+    segments: list[list[tuple[float, float]]] = []
+    current: list[tuple[float, float]] = []
+    for i, v in enumerate(values):
+        if v is None:
+            if current:
+                segments.append(current)
+                current = []
+            continue
+        x = i * step
+        y = h_ - ((float(v) - lo) / span) * (h_ - 2) - 1
+        current.append((x, y))
+    if current:
+        segments.append(current)
+    parts = [f'<svg class="spark" width="{w}" height="{h_}" viewBox="0 0 {w} {h_}">']
+    for seg in segments:
+        if len(seg) == 1:
+            x, y = seg[0]
+            parts.append(f'<circle cx="{x:.2f}" cy="{y:.2f}" r="1.5" fill="currentColor"/>')
+        else:
+            pts = ' '.join(f'{x:.2f},{y:.2f}' for x, y in seg)
+            parts.append(f'<polyline points="{pts}" stroke="currentColor" stroke-width="1.25" fill="none"/>')
+    parts.append('</svg>')
+    return ''.join(parts)

bobframes/reports/discovery.py

@@ -0,0 +1,118 @@
+"""Catalog enumeration and drop-metadata dataclasses."""
+
+from __future__ import annotations
+
+import os
+from collections import Counter
+from dataclasses import dataclass, field
+
+import pyarrow.parquet as papq
+
+from .. import paths as _paths
+
+
+@dataclass
+class DropRow:
+    area: str
+    drop_date: str
+    drop_label: str
+    drop_dir: str
+    ok_captures: int
+
+
+@dataclass
+class DropSet:
+    """All (area, drop_date, drop_label, drop_dir) tuples for one label+date."""
+    label: str
+    date: str
+    rows: list[DropRow] = field(default_factory=list)
+
+    @property
+    def key(self) -> str:
+        if self.date and self.label:
+            return f'{self.date}_{self.label}'
+        return self.label or self.date or 'unknown'
+
+    @property
+    def n_captures(self) -> int:
+        return sum(r.ok_captures for r in self.rows)
+
+    @property
+    def areas(self) -> list[str]:
+        return sorted({r.area for r in self.rows})
+
+
+def discover_drops(root: str) -> list[DropSet]:
+    """Read _catalog.parquet, group by (drop_date, drop_label), filter replay_status='ok'.
+
+    Returns list of DropSet sorted by drop_date asc then drop_label asc.
+    """
+    cat_path = _paths.catalog_parquet(root)
+    if not os.path.exists(cat_path):
+        return []
+    cols_wanted = ['area', 'drop_date', 'drop_label', 'capture',
+                   'replay_status', 'analysis_out_path']
+    try:
+        t = papq.read_table(cat_path, columns=cols_wanted)
+    except Exception:
+        return []
+
+    areas = t.column('area').to_pylist()
+    dates = t.column('drop_date').to_pylist()
+    labels = t.column('drop_label').to_pylist()
+    statuses = t.column('replay_status').to_pylist()
+    aop = t.column('analysis_out_path').to_pylist()
+
+    ok_by_drop: dict[tuple[str, str, str], int] = Counter()
+    path_by_drop: dict[tuple[str, str, str], str] = {}
+    for a, d, l, s, p in zip(areas, dates, labels, statuses, aop):
+        if s == 'ok':
+            ok_by_drop[(a, d, l)] += 1
+        path_by_drop.setdefault((a, d, l), p)
+
+    seen_sets: dict[tuple[str, str], DropSet] = {}
+    for (a, d, l), p in path_by_drop.items():
+        key = (d, l)
+        if key not in seen_sets:
+            seen_sets[key] = DropSet(label=l, date=d)
+        # New: analysis_out_path stored relative under _data/. resolve_drop_dir
+        # already points at <root>/_data/<area>/<drop> (the data dir).
+        seen_sets[key].rows.append(DropRow(
+            area=a, drop_date=d, drop_label=l,
+            drop_dir=_paths.resolve_drop_dir(root, p) if p else '',
+            ok_captures=ok_by_drop.get((a, d, l), 0),
+        ))
+
+    return sorted(seen_sets.values(), key=lambda s: (s.date, s.label))
+
+
+def resolve_drop_set(root: str, *,
+                     label: str | None,
+                     date: str | None = None) -> DropSet | None:
+    drops = discover_drops(root)
+    for d in drops:
+        if label and d.label != label:
+            continue
+        if date and d.date != date:
+            continue
+        return d
+    return None
+
+
+def ok_capture_set(root: str) -> set[tuple]:
+    """Return {(area, drop_date, drop_label, capture)} where replay_status='ok'."""
+    cat_path = _paths.catalog_parquet(root)
+    if not os.path.exists(cat_path):
+        return set()
+    try:
+        t = papq.read_table(cat_path, columns=['area', 'drop_date', 'drop_label',
+                                                'capture', 'replay_status'])
+    except Exception:
+        return set()
+    cols = {c: t.column(c).to_pylist() for c in t.column_names}
+    out = set()
+    for i in range(t.num_rows):
+        if cols['replay_status'][i] == 'ok':
+            out.add((cols['area'][i], cols['drop_date'][i],
+                     cols['drop_label'][i], cols['capture'][i]))
+    return out

bobframes/reports/draws_by_class.py

@@ -0,0 +1,165 @@
+"""Draws-by-class report.
+
+Stacked horizontal bars per (area, drop_date), proportional within the bar.
+Segments colored by draw_class. Below: raw-count table.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from collections import Counter, defaultdict
+
+import pyarrow.parquet as papq
+
+from . import base
+
+
+def _gather_from_drops(drops: list) -> tuple[dict, list, list, int]:
+    """Return (counts, areas, drop_keys, total_captures).
+
+    counts[(area, drop_key)][draw_class] = int.
+    """
+    counts: dict[tuple[str, str], Counter] = defaultdict(Counter)
+    areas: set[str] = set()
+    drop_keys: list[str] = []
+    seen_captures: set[tuple] = set()
+
+    for d in drops:
+        drop_keys.append(d.key)
+        for r in d.rows:
+            p = os.path.join(r.drop_dir, 'draws.parquet')
+            if not os.path.exists(p):
+                continue
+            try:
+                t = papq.read_table(p, columns=['area', 'capture', 'draw_class'])
+            except Exception:
+                continue
+            if t.num_rows == 0:
+                continue
+            a = t.column('area').to_pylist()
+            cap = t.column('capture').to_pylist()
+            cl = t.column('draw_class').to_pylist()
+            for i in range(t.num_rows):
+                counts[(a[i], d.key)][cl[i] or 'other'] += 1
+                areas.add(a[i])
+                seen_captures.add((a[i], d.key, cap[i]))
+
+    return counts, sorted(areas), drop_keys, len(seen_captures)
+
+
+def _build_table(counts: dict, drop_keys: list) -> str:
+    classes = base.DRAW_CLASSES
+    rows = []
+    rows.append('<table class="report"><thead><tr>')
+    rows.append('<th>area</th><th>drop</th><th class="num">total</th>')
+    for c in classes:
+        rows.append(f'<th class="num">{base.h(c)}</th>')
+    rows.append('<th class="num">prepass / opaque</th>')
+    rows.append('</tr></thead><tbody>')
+
+    keys = sorted(counts.keys(), key=lambda k: (k[1], k[0]))
+    for area, date in keys:
+        cc = counts[(area, date)]
+        total = sum(cc.values())
+        rows.append('<tr>')
+        rows.append(f'<td>{base.h(area)}</td>')
+        rows.append(f'<td>{base.h(date)}</td>')
+        rows.append(f'<td class="num">{base.fmt_int(total)}</td>')
+        for c in classes:
+            n = cc.get(c, 0)
+            rows.append(f'<td class="num">{base.fmt_int(n)}</td>')
+        ratio = (cc.get('prepass', 0) / cc['opaque']) if cc.get('opaque', 0) else 0.0
+        rows.append(f'<td class="num">{base.fmt_float(ratio, 2)}</td>')
+        rows.append('</tr>')
+    rows.append('</tbody></table>')
+    return '\n'.join(rows)
+
+
+def _compute_kpis(counts: dict, areas: list) -> list:
+    """Hero KPIs: total draws, n areas, median prepass/opaque ratio, dominant class."""
+    total = sum(sum(cc.values()) for cc in counts.values())
+    ratios = []
+    class_totals: Counter = Counter()
+    for cc in counts.values():
+        for cls, n in cc.items():
+            class_totals[cls] += n
+        op = cc.get('opaque', 0)
+        if op:
+            ratios.append(cc.get('prepass', 0) / op)
+    median_ratio = (sorted(ratios)[len(ratios) // 2]
+                    if ratios else 0.0)
+    dominant_cls = (class_totals.most_common(1)[0][0]
+                    if class_totals else '')
+    return [
+        {'label': 'total draws', 'value': base.fmt_int(total)},
+        {'label': 'areas',       'value': base.fmt_int(len(areas))},
+        {'label': 'prepass/opaque (med)', 'value': base.fmt_float(median_ratio, 2)},
+        {'label': 'dominant class', 'value': dominant_cls or '-'},
+    ]
+
+
+def build(root: str, *, drops: list | None = None, ab=None) -> str:
+    if drops is None:
+        drops = base.discover_drops(root)
+    counts, areas, drop_keys, total_captures = _gather_from_drops(drops)
+
+    parts = [base.page_open('draws by class', hdr_offset_px=120)]
+    parts.append(base.header(
+        'draws by class',
+        drops=len(drops), captures=total_captures, build_ts=base.now_iso(),
+        crumb_depth=base.crumb_depth(ab),
+    ))
+    parts.append(base.ab_strip(ab))
+    parts.append(base.ab_picker_for(root, 'draws_by_class', ab=ab))
+
+    # Summary bar: dominant class
+    class_totals: Counter = Counter()
+    for cc in counts.values():
+        for cls, n in cc.items():
+            class_totals[cls] += n
+    grand_total = sum(class_totals.values()) or 1
+    top_three = class_totals.most_common(3)
+    if top_three:
+        dom_cls, dom_n = top_three[0]
+        dom_pct = 100.0 * dom_n / grand_total
+        sub_bits = [f'{cls} {base.fmt_float(100.0 * n / grand_total, 1)}%'
+                    for cls, n in top_three[1:]]
+        sub_text = f'across {len(areas)} areas; next: ' + ', '.join(sub_bits) if sub_bits else f'across {len(areas)} areas'
+        parts.append(base.summary_bar(
+            'dominant class',
+            f'{dom_cls} {base.fmt_float(dom_pct, 1)}%',
+            sub=sub_text,
+            tone='neutral',
+        ))
+
+    # Section 1: stacked share bars
+    parts.append('<h2 id="stacked">stacked share per area / drop</h2>')
+    sec1_body = ['<div class="table-wrap">', base.legend()]
+    keys = sorted(counts.keys(), key=lambda k: (k[1], k[0]))
+    for area, date in keys:
+        cc = counts[(area, date)]
+        total = sum(cc.values())
+        label = f'{area} / {date}'
+        sec1_body.append('<div class="bar-row">')
+        sec1_body.append(f'<span class="key" title="{base.h(label)}">{base.h(label)}</span>')
+        sec1_body.append(base.class_segments_bar(dict(cc), total))
+        sec1_body.append(f'<span class="total">{base.fmt_int(total)}</span>')
+        sec1_body.append('</div>')
+    sec1_body.append('</div>')
+    parts.append(''.join(sec1_body))
+
+    # Section 2: raw counts table
+    parts.append('<h2 id="counts">raw counts per class</h2>')
+    parts.append('<div class="table-wrap"><rdc-sortable-table data-default-sort="opaque" data-default-dir="desc">')
+    parts.append(_build_table(counts, drop_keys))
+    parts.append('</rdc-sortable-table></div>')
+
+    parts.append(base.page_close())
+
+    out_path = base.output_path(root, 'draws_by_class', ab)
+    return base.write_report(out_path, parts)
+
+
+if __name__ == '__main__':
+    sys.exit(base.run_report(build, module_name='draws_by_class'))

bobframes/reports/formatters.py

@@ -0,0 +1,122 @@
+"""Cell renderers and text-normalization helpers used across reports."""
+
+from __future__ import annotations
+
+import html as _html
+import re
+
+
+_BANNED_CHROME_CHARS = re.compile(r'[—–…“”‘’→←↑↓×·]')
+
+
+def fmt_int(v) -> str:
+    if v is None or v == '':
+        return ''
+    try:
+        return f'{int(v):,}'
+    except (TypeError, ValueError):
+        return ''
+
+
+def fmt_float(v, prec: int = 3) -> str:
+    if v is None or v == '':
+        return ''
+    try:
+        return f'{float(v):,.{prec}f}'
+    except (TypeError, ValueError):
+        return ''
+
+
+def fmt_bytes(v) -> str:
+    return fmt_int(v)
+
+
+def fmt_pct(v, prec: int = 1) -> str:
+    if v is None or v == '':
+        return ''
+    try:
+        return f'{float(v):.{prec}f}%'
+    except (TypeError, ValueError):
+        return ''
+
+
+def fmt_id_short(v, n: int = 12) -> str:
+    if not v:
+        return ''
+    s = str(v)
+    return s[:n] if len(s) > n else s
+
+
+def mesh_hash_short(hsh, n: int = 12) -> str:
+    return fmt_id_short(hsh, n)
+
+
+def safe_chrome_text(s) -> str:
+    """Escape + scrub banned chrome chars. Apply to all chrome strings outside <table>."""
+    if s is None:
+        return ''
+    scrubbed = _BANNED_CHROME_CHARS.sub('_', str(s))
+    return _html.escape(scrubbed)
+
+
+def trunc_mid(s: str | None, max_len: int = 60) -> str:
+    if s is None:
+        return ''
+    s = str(s)
+    if len(s) <= max_len:
+        return s
+    keep = max_len - 3
+    head = keep // 2
+    tail = keep - head
+    return s[:head] + '...' + s[-tail:]
+
+
+def trunc_left(s: str | None, max_len: int = 60) -> str:
+    """Truncate from the left, keep the suffix. For pass paths whose tail carries the signal."""
+    if s is None:
+        return ''
+    s = str(s)
+    if len(s) <= max_len:
+        return s
+    return '...' + s[-(max_len - 3):]
+
+
+def pass_short(path: str | None) -> str:
+    """Reduce a UE pass path to its meaningful tail.
+
+    Strips FRDGBuilder::Execute/MobileSceneRender/ prefix.
+    Collapses /Engine/EngineMaterials/<Name>.<Name>/ to <Name>/.
+    Collapses any `/<Foo>.<Foo>` repeated-name asset pattern to `/<Foo>`.
+    """
+    if not path:
+        return ''
+    s = str(path)
+    if s.startswith('FRDGBuilder::Execute/'):
+        s = s[len('FRDGBuilder::Execute/'):]
+    if s.startswith('MobileSceneRender/'):
+        s = s[len('MobileSceneRender/'):]
+    # Collapse /A/B/C.../<Name>.<Name> SM_X  → <Name> SM_X (UE FName redundant)
+    parts = s.split('/')
+    cleaned = []
+    for p in parts:
+        if not p:
+            continue
+        # asset prefix like "/Engine/EngineMaterials" is just noise
+        if p in ('Engine', 'EngineMaterials'):
+            continue
+        # collapse "Name.Name" → "Name"
+        if '.' in p:
+            head, _, rest = p.partition('.')
+            after = rest.split(' ', 1)
+            if after[0] == head:
+                p = head if len(after) == 1 else f'{head} {after[1]}'
+        cleaned.append(p)
+    return '/'.join(cleaned)
+
+
+def pass_suffix(path: str | None) -> str:
+    """Last meaningful segment of a pass path, with UE noise stripped."""
+    short = pass_short(path)
+    if not short:
+        return ''
+    return short.rsplit('/', 1)[-1]