shellwrapped 0.1.0__py3-none-any.whl

shellwrapped/__init__.py

@@ -0,0 +1,2 @@
+"""shellwrapped: Spotify Wrapped for your shell history."""
+__version__ = "0.1.0"

shellwrapped/__main__.py

@@ -0,0 +1,3 @@
+from .cli import run
+
+run()

shellwrapped/card.py

@@ -0,0 +1,95 @@
+"""Render a 1200x675 share card (the size X, LinkedIn and Slack previews use)."""
+from __future__ import annotations
+
+from importlib import resources
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFilter, ImageFont
+
+W, H = 1200, 675
+
+
+def _font(name: str, size: int) -> ImageFont.FreeTypeFont:
+    with resources.as_file(resources.files(__package__) / "fonts" / name) as p:
+        return ImageFont.truetype(str(p), size)
+
+
+def _gradient(top: tuple, bottom: tuple) -> Image.Image:
+    img = Image.new("RGB", (W, H), top)
+    d = ImageDraw.Draw(img)
+    for y in range(H):
+        t = y / (H - 1)
+        d.line([(0, y), (W, y)], fill=tuple(int(top[i] + (bottom[i] - top[i]) * t) for i in range(3)))
+    return img
+
+
+def _fit(draw: ImageDraw.ImageDraw, text: str, font_name: str, size: int, max_w: int) -> ImageFont.FreeTypeFont:
+    f = _font(font_name, size)
+    while draw.textlength(text, font=f) > max_w and size > 14:
+        size -= 2
+        f = _font(font_name, size)
+    return f
+
+
+def render(path: str | Path, *, brand: str, year_label: str, persona: str, tagline: str,
+           stats: list[tuple[str, str]], bars: list[tuple[str, int]], bars_title: str, footer: str,
+           accent=(255, 107, 87), top=(24, 18, 43), bottom=(10, 10, 18)) -> Path:
+    img = _gradient(top, bottom)
+    d = ImageDraw.Draw(img)
+    ink, dim = (245, 243, 255), (160, 156, 190)
+
+    # glow behind the title
+    glow = Image.new("RGBA", (W, H), (0, 0, 0, 0))
+    gd = ImageDraw.Draw(glow)
+    gd.ellipse((-260, -320, 640, 360), fill=accent + (70,))
+    gd.ellipse((820, 380, 1500, 900), fill=(120, 90, 255, 40))
+    glow = glow.filter(ImageFilter.GaussianBlur(120))
+    img = Image.alpha_composite(img.convert("RGBA"), glow)
+    tiles = Image.new("RGBA", (W, H), (0, 0, 0, 0))
+    td = ImageDraw.Draw(tiles)
+
+    for i in range(min(len(stats), 4)):
+        x = 64 + i * (248 + 22)
+        td.rounded_rectangle((x, 300, x + 248, 432), radius=18, fill=(255, 255, 255, 14),
+                             outline=(255, 255, 255, 40), width=2)
+    img = Image.alpha_composite(img, tiles).convert("RGB")
+    d = ImageDraw.Draw(img)
+
+    d.text((64, 52), brand, font=_font("Inter-Bold.otf", 26), fill=accent)
+    bw = d.textlength(brand, font=_font("Inter-Bold.otf", 26))
+    d.text((64 + bw + 14, 52), year_label, font=_font("Inter-Regular.otf", 26), fill=dim)
+
+    title_f = _fit(d, persona, "InterDisplay-Black.otf", 76, 1060)
+    d.text((62, 96), persona, font=title_f, fill=ink)
+    d.text((66, 96 + title_f.size + 14), tagline, font=_fit(d, tagline, "Inter-Regular.otf", 28, 1060), fill=dim)
+
+    # stat tiles
+    y0, tile_w, gap = 300, 248, 22
+    for i, (label, value) in enumerate(stats[:4]):
+        x = 64 + i * (tile_w + gap)
+        vf = _fit(d, value, "InterDisplay-Black.otf", 52, tile_w - 36)
+        d.text((x + 20, y0 + 18), value, font=vf, fill=ink)
+        d.text((x + 20, y0 + 90), label.upper(), font=_fit(d, label.upper(), "Inter-Bold.otf", 17, tile_w - 36),
+               fill=dim)
+
+    # bar chart
+    by = 470
+    d.text((64, by), bars_title.upper(), font=_font("Inter-Bold.otf", 17), fill=dim)
+    if bars:
+        mx = max(v for _, v in bars) or 1
+        name_f, val_f = _font("Inter-Bold.otf", 22), _font("Inter-Regular.otf", 20)
+        for i, (name, v) in enumerate(bars[:5]):
+            y = by + 36 + i * 30
+            d.text((64, y), name, font=name_f, fill=ink)
+            x0, x1 = 230, 230 + int(560 * v / mx)
+            d.rounded_rectangle((x0, y + 6, max(x1, x0 + 8), y + 22), radius=8, fill=accent)
+            d.text((max(x1, x0 + 8) + 12, y + 1), f"{v:,}", font=val_f, fill=dim)
+
+    ff = _font("Inter-Bold.otf", 22)
+    fw = d.textlength(footer, font=ff)
+    d.rounded_rectangle((W - 64 - fw - 36, H - 82, W - 64, H - 40), radius=21, fill=accent)
+    d.text((W - 64 - fw - 18, H - 74), footer, font=ff, fill=(20, 16, 34))
+
+    path = Path(path)
+    img.save(path, optimize=True)
+    return path

shellwrapped/cli.py

@@ -0,0 +1,145 @@
+"""shellwrapped: Spotify Wrapped for your shell history."""
+from __future__ import annotations
+
+import argparse
+import sys
+from datetime import date
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from . import __version__, card
+from .history import history_files, load
+from .show import Story
+from .stats import Wrapped, compute
+
+ACCENT = "#ff6b57"
+
+
+def clock(h: int) -> str:
+    return f"{(h % 12) or 12} {'am' if h < 12 else 'pm'}"
+
+
+def story(w: Wrapped, s: Story, label: str) -> None:
+    s.words("shellwrapped", f"Your {label} in the terminal", "Let's see what your shell remembers.", hold=1.8)
+    s.number("commands run", w.commands, f"{w.unique:,} of them unique")
+    s.bars("your top commands", w.top[:6], f"{w.top[0][0]} alone: {w.top[0][1]:,} times" if w.top else "")
+    if w.top_line:
+        s.words("your most-repeated command", w.top_line[0], f"{w.top_line[1]:,} times. Maybe it deserves an alias?")
+    if w.git:
+        s.bars("git, your way", w.git, f"{w.git[0][1]:,} × git {w.git[0][0]}")
+    if w.typos:
+        typed, meant, n = w.typos[0]
+        s.number(f"times you typed '{typed}' instead of '{meant}'", n,
+                 f"{w.typo_total:,} typos in total. Your fingers are faster than your spelling.")
+    if w.has_time and w.peak_hour is not None:
+        s.words("your terminal's rush hour", clock(w.peak_hour),
+                f"{w.night_share:.0%} of your commands ran between 10pm and 5am")
+        if w.longest_session_min >= 30:
+            s.number("minutes in your longest session", w.longest_session_min,
+                     f"Busiest day: {w.busiest_day:%B} {w.busiest_day.day} with {w.busiest_day_count:,} commands")
+    facts = []
+    if w.sudo:
+        facts.append(f"sudo × {w.sudo:,}" + (f"  (sudo !! × {w.sudo_bang})" if w.sudo_bang else ""))
+    if w.cd_ls:
+        facts.append(f"cd then immediately ls × {w.cd_ls:,}")
+    if w.force_push:
+        facts.append(f"git push --force × {w.force_push:,}")
+    if w.rm_rf:
+        facts.append(f"rm -rf × {w.rm_rf:,}")
+    if w.clears:
+        facts.append(f"clear × {w.clears:,}")
+    if facts:
+        s.words("habits", "  ·  ".join(facts[:3]), "No judgement.")
+    s.words("your terminal personality", w.persona[0], w.persona[1], hold=3.0)
+
+
+def summary(w: Wrapped, label: str) -> Panel:
+    t = Table.grid(padding=(0, 3))
+    t.add_column(style="#a09cbe", justify="right")
+    t.add_column(style="bold #f5f3ff")
+    t.add_row("commands", f"{w.commands:,}  [#a09cbe]({w.unique:,} unique)[/]")
+    if w.top:
+        t.add_row("top commands", "  ".join(f"{p} [#a09cbe]{n:,}[/]" for p, n in w.top[:5]))
+    if w.git:
+        t.add_row("git", "  ".join(f"{g} [#a09cbe]{n:,}[/]" for g, n in w.git[:4]))
+    if w.top_line:
+        t.add_row("most repeated", f"{w.top_line[0]}  [#a09cbe]×{w.top_line[1]:,}[/]")
+    if w.typos:
+        t.add_row("typos", ", ".join(f"{a}→{b} ×{n}" for a, b, n in w.typos[:3]) + f"  [#a09cbe]({w.typo_total} total)[/]")
+    if w.has_time and w.peak_hour is not None:
+        t.add_row("peak hour", f"{clock(w.peak_hour)}  [#a09cbe]{w.night_share:.0%} after 10pm · "
+                               f"{w.active_days} active days · longest session {w.longest_session_min} min[/]")
+    t.add_row("longest command", f"{w.longest:,} characters")
+    t.add_row("persona", f"[{ACCENT}]{w.persona[0]}[/]  [#a09cbe]{w.persona[1]}[/]")
+    return Panel(t, title=f"[bold {ACCENT}]shellwrapped[/] [#a09cbe]{label}[/]", title_align="left",
+                 border_style=ACCENT, padding=(1, 2))
+
+
+def make_card(w: Wrapped, label: str, path: Path) -> Path:
+    top = w.top[0] if w.top else ("-", 0)
+    stats = [("commands", f"{w.commands:,}"), (f"× {top[0]}", f"{top[1]:,}")]
+    stats.append(("typos", f"{w.typo_total:,}") if w.typos else ("unique commands", f"{w.unique:,}"))
+    stats.append(("peak hour", clock(w.peak_hour)) if w.has_time and w.peak_hour is not None
+                 else ("longest command", f"{w.longest:,} ch"))
+    return card.render(path, brand="shellwrapped", year_label=label, persona=w.persona[0], tagline=w.persona[1],
+                       stats=stats, bars=w.top[:5], bars_title="top commands", footer="uvx shellwrapped")
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(prog="shellwrapped", description="Spotify Wrapped for your shell history.")
+    p.add_argument("--year", type=int, default=date.today().year, help="year to wrap (default: this year)")
+    p.add_argument("--all-time", action="store_true", help="use your whole history, not just one year")
+    p.add_argument("--file", type=Path, action="append", help="history file to read (repeatable)")
+    p.add_argument("--shell", choices=["zsh", "bash", "fish", "powershell"], help="format of --file")
+    p.add_argument("--no-anim", action="store_true", help="skip the animation, just print the summary")
+    p.add_argument("--speed", type=float, default=1.0, help="animation speed multiplier")
+    p.add_argument("--card", type=Path, help="where to save the share card (default: ./shellwrapped-<year>.png)")
+    p.add_argument("--no-card", action="store_true", help="don't write a share card")
+    p.add_argument("--version", action="version", version=f"shellwrapped {__version__}")
+    a = p.parse_args(argv)
+    console = Console()
+
+    files = [(f, a.shell or ("zsh" if "zsh" in f.name else "bash")) for f in a.file] if a.file else history_files()
+    if not files:
+        console.print("No shell history found. Point me at one with --file ~/.zsh_history")
+        return 1
+    commands = load(files)
+    timed = any(c.when for c in commands)
+    year = None if a.all_time or not timed else a.year
+    w = compute(commands, year)
+    if w.commands == 0:
+        console.print(f"No commands found for {a.year}. Try --all-time.")
+        return 1
+    label = str(year) if year else "all time"
+
+    if not a.no_anim and console.is_terminal:
+        try:
+            story(w, Story(console, ACCENT, a.speed), label)
+        except KeyboardInterrupt:
+            pass
+    console.print(summary(w, label))
+    if not timed:
+        console.print("[#a09cbe]Your history has no timestamps, so this covers everything it remembers. For "
+                      "per-year stats next time: `setopt EXTENDED_HISTORY` (zsh) or `export HISTTIMEFORMAT='%F %T '`"
+                      " (bash).[/]")
+    if not a.no_card:
+        out = a.card or Path(f"shellwrapped-{label.replace(' ', '-')}.png")
+        try:
+            make_card(w, label, out)
+            console.print(f"\n[bold {ACCENT}]Share card saved:[/] {out}  [#a09cbe](no commands or paths on it, "
+                          f"just counts and program names)[/]")
+        except OSError as e:
+            console.print(f"[#a09cbe]Couldn't save the share card: {e}[/]")
+    return 0
+
+
+def run() -> None:
+    sys.exit(main())
+
+
+if __name__ == "__main__":
+    run()

shellwrapped/fonts/OFL.txt

@@ -0,0 +1,88 @@
+Inter font: Copyright (c) 2016-2023 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font
+creation efforts of academic and linguistic communities, and to
+provide a free and open framework in which fonts may be shared and
+improved in partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any
+reserved names are not used by derivative works. The fonts and
+derivatives, however, cannot be released under any other type of
+license. The requirement for fonts to remain under this license
+does not apply to any document created using the fonts or their
+derivatives.
+
+DEFINITIONS
+Font Software refers to the set of files released by the
+Copyright Holder(s) under this license and clearly marked as such.
+This may include source files, build scripts and documentation.
+
+Reserved Font Name refers to any names specified as such after
+the copyright statement(s).
+
+Original Version refers to the collection of Font Software
+components as distributed by the Copyright Holder(s).
+
+Modified Version refers to any derivative made by adding to,
+deleting, or substituting in part or in whole any of the components
+of the Original Version, by changing formats or by porting the Font
+Software to a new environment.
+
+Author refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of the Font Software, to use, study, copy, merge,
+embed, modify, redistribute, and sell modified and unmodified copies
+of the Font Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+   in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+   redistributed and/or sold with any software, provided that each
+   copy contains the above copyright notice and this license. These
+   can be included either as stand-alone text files, human-readable
+   headers or in the appropriate machine-readable metadata fields
+   within text or binary files as long as those fields can be easily
+   viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+   Name(s) unless explicit written permission is granted by the
+   corresponding Copyright Holder. This restriction only applies to
+   the primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the
+   Font Software shall not be used to promote, endorse or advertise
+   any Modified Version, except to acknowledge the contribution(s)
+   of the Copyright Holder(s) and the Author(s) or with their
+   explicit written permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+   must be distributed entirely under this license, and must not be
+   distributed under any other license. The requirement for fonts to
+   remain under this license does not apply to any document created
+   using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions
+are not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL
+THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR
+CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT
+SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.

shellwrapped/history.py

@@ -0,0 +1,152 @@
+"""Read shell history files (zsh, bash, fish, PowerShell) into timestamped commands."""
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Command:
+    text: str
+    when: datetime | None  # None when the shell didn't record a timestamp
+    shell: str
+
+
+def _home() -> Path:
+    return Path(os.environ.get("SHELLWRAPPED_HOME") or Path.home())
+
+
+def unmetafy(raw: bytes) -> bytes:
+    """zsh stores bytes >= 0x80 'metafied': 0x83 followed by the byte XOR 0x20."""
+    if b"\x83" not in raw:
+        return raw
+    out = bytearray()
+    it = iter(raw)
+    for b in it:
+        if b == 0x83:
+            nxt = next(it, None)
+            if nxt is not None:
+                out.append(nxt ^ 0x20)
+        else:
+            out.append(b)
+    return bytes(out)
+
+
+def _ts(s: str) -> datetime | None:
+    try:
+        v = int(s)
+        return datetime.fromtimestamp(v) if 0 < v < 4_102_444_800 else None
+    except (ValueError, OSError, OverflowError):
+        return None
+
+
+ZSH_EXT = re.compile(r"^: (\d+):\d+;(.*)$", re.S)
+
+
+def parse_zsh(raw: bytes) -> list[Command]:
+    text = unmetafy(raw).decode("utf-8", errors="replace")
+    out: list[Command] = []
+    buf: list[str] = []
+    when = None
+    for line in text.split("\n"):
+        if buf:  # inside a multi-line command (previous line ended with a backslash)
+            buf.append(line)
+            if not line.endswith("\\"):
+                out.append(Command("\n".join(buf), when, "zsh"))
+                buf = []
+            continue
+        m = ZSH_EXT.match(line)
+        cmd, when = (m.group(2), _ts(m.group(1))) if m else (line, None)
+        if not cmd.strip():
+            continue
+        if cmd.endswith("\\"):
+            buf = [cmd]
+        else:
+            out.append(Command(cmd, when, "zsh"))
+    if buf:
+        out.append(Command("\n".join(buf), when, "zsh"))
+    return out
+
+
+def parse_bash(raw: bytes) -> list[Command]:
+    out, when = [], None
+    for line in raw.decode("utf-8", errors="replace").splitlines():
+        if line.startswith("#") and line[1:].isdigit():  # HISTTIMEFORMAT timestamps
+            when = _ts(line[1:])
+            continue
+        if line.strip():
+            out.append(Command(line, when, "bash"))
+            when = None
+    return out
+
+
+def parse_fish(raw: bytes) -> list[Command]:
+    out: list[Command] = []
+    cmd = None
+    for line in raw.decode("utf-8", errors="replace").splitlines():
+        if line.startswith("- cmd: "):
+            if cmd is not None:
+                out.append(Command(cmd, None, "fish"))
+            cmd = line[7:].replace("\\n", "\n").replace("\\\\", "\\")
+        elif line.startswith("  when: ") and cmd is not None:
+            out.append(Command(cmd, _ts(line[8:].strip()), "fish"))
+            cmd = None
+    if cmd is not None:
+        out.append(Command(cmd, None, "fish"))
+    return out
+
+
+def parse_powershell(raw: bytes) -> list[Command]:
+    text = raw.decode("utf-8-sig", errors="replace")
+    out, buf = [], []
+    for line in text.splitlines():
+        buf.append(line)
+        if line.endswith("`"):
+            continue
+        cmd = "\n".join(buf)
+        buf = []
+        if cmd.strip():
+            out.append(Command(cmd, None, "powershell"))
+    return out
+
+
+def history_files(home: Path | None = None) -> list[tuple[Path, str]]:
+    h = home or _home()
+    appdata = Path(os.environ.get("APPDATA", h / "AppData/Roaming"))
+    candidates = []
+    if os.environ.get("HISTFILE"):
+        p = Path(os.environ["HISTFILE"])
+        candidates.append((p, "zsh" if "zsh" in p.name or "zhist" in p.name else "bash"))
+    candidates += [
+        (h / ".zsh_history", "zsh"), (h / ".zhistory", "zsh"), (h / ".histfile", "zsh"),
+        (h / ".bash_history", "bash"),
+        (h / ".local/share/fish/fish_history", "fish"),
+        (appdata / "Microsoft/Windows/PowerShell/PSReadLine/ConsoleHost_history.txt", "powershell"),
+        (h / ".local/share/powershell/PSReadLine/ConsoleHost_history.txt", "powershell"),
+    ]
+    seen, out = set(), []
+    for p, shell in candidates:
+        try:
+            rp = p.resolve()
+            if rp not in seen and rp.is_file() and rp.stat().st_size > 0:
+                seen.add(rp)
+                out.append((rp, shell))
+        except OSError:
+            continue
+    return out
+
+
+PARSERS = {"zsh": parse_zsh, "bash": parse_bash, "fish": parse_fish, "powershell": parse_powershell}
+
+
+def load(files: list[tuple[Path, str]] | None = None) -> list[Command]:
+    commands: list[Command] = []
+    for path, shell in files if files is not None else history_files():
+        try:
+            commands += PARSERS[shell](path.read_bytes())
+        except OSError:
+            continue
+    return commands

shellwrapped/show.py

@@ -0,0 +1,108 @@
+"""Animated terminal story: one stat per screen, numbers counting up in block digits."""
+from __future__ import annotations
+
+import time
+
+from rich.align import Align
+from rich.console import Console, Group
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
+
+GLYPHS = {
+    "0": ["▄▀▀▄", "█  █", "▀▄▄▀"], "1": [" ▄█ ", "  █ ", " ▄█▄"], "2": ["▄▀▀▄", "  ▄▀", "▄█▄▄"],
+    "3": ["▀▀▀█", " ▀▀▄", "▄▄▄▀"], "4": ["█  █", "▀▀▀█", "   █"], "5": ["█▀▀▀", "▀▀▀▄", "▄▄▄▀"],
+    "6": ["▄▀▀ ", "█▄▄ ", "▀▄▄▀"], "7": ["▀▀▀█", "  █ ", " █  "], "8": ["▄▀▀▄", "▄▀▀▄", "▀▄▄▀"],
+    "9": ["▄▀▀▄", "▀▄▄█", " ▄▄▀"], ",": ["  ", "  ", "▄▀"], ".": [" ", " ", "▄"], ":": [" ", "▀", "▀"],
+    "%": ["▀ ▄▀", " ▄▀ ", "▄▀ ▄"], " ": ["  ", "  ", "  "], "-": ["   ", "▀▀▀", "   "],
+}
+
+
+def big(text: str, style: str) -> Text:
+    rows = ["", "", ""]
+    for ch in text:
+        g = GLYPHS.get(ch)
+        if g is None:
+            continue
+        for i in range(3):
+            rows[i] += g[i] + " "
+    return Text("\n".join(r.rstrip() for r in rows), style=style, justify="center")
+
+
+def headline_text(text: str, style: str, max_width: int) -> Text:
+    """Large FIGlet lettering when it fits, plain bold text otherwise. Times/numbers use block digits."""
+    import re
+
+    m = re.fullmatch(r"([\d:,.%]+)\s*(am|pm)?", text.strip())
+    if m:
+        out = big(m.group(1), style)
+        if m.group(2):
+            out.append("\n" + m.group(2), style=style)
+        return out
+    try:
+        import pyfiglet
+
+        art = pyfiglet.figlet_format(text, font="future", width=1000).rstrip("\n")
+        if art.strip() and max(len(l) for l in art.splitlines()) <= max_width:
+            return Text(art, style=style, justify="center")
+    except Exception:  # missing glyphs, missing font: fall back to plain text
+        pass
+    return Text(text, style=style, justify="center")
+
+
+class Story:
+    def __init__(self, console: Console, accent: str = "#ff6b57", speed: float = 1.0, animate: bool = True):
+        self.c, self.accent, self.speed, self.animate = console, accent, speed, animate
+
+    def _panel(self, label: str, body, caption: str = "") -> Panel:
+        parts = [Text(label.upper(), style="bold #a09cbe", justify="center"), Text(""), body]
+        if caption:
+            parts += [Text(""), Text(caption, style="#d8d4f0", justify="center")]
+        height = max(13, self.c.size.height - 2)
+        return Panel(Align.center(Group(*parts), vertical="middle"), border_style=self.accent, height=height)
+
+    def number(self, label: str, value: int, caption: str = "", fmt: str = "{:,}", hold: float = 2.2) -> None:
+        if not self.animate:
+            return
+        steps = 28
+        with Live(self._panel(label, big(fmt.format(0), f"bold {self.accent}")), console=self.c,
+                  refresh_per_second=40, transient=True, screen=True) as live:
+            for i in range(1, steps + 1):
+                v = round(value * (1 - (1 - i / steps) ** 3))  # ease-out
+                live.update(self._panel(label, big(fmt.format(v), f"bold {self.accent}"),
+                                        caption if i == steps else ""))
+                time.sleep(0.9 / steps / self.speed)
+            time.sleep(hold / self.speed)
+
+    def words(self, label: str, headline: str, caption: str = "", hold: float = 2.4) -> None:
+        if not self.animate:
+            return
+        with Live(self._panel(label, Text("")), console=self.c, refresh_per_second=40, transient=True,
+                  screen=True) as live:
+            shown = ""
+            for ch in headline:
+                shown += ch
+                live.update(self._panel(label, Text(shown, style=f"bold {self.accent}", justify="center")))
+                time.sleep(0.035 / self.speed)
+            live.update(self._panel(label, headline_text(headline, f"bold {self.accent}", self.c.size.width - 8),
+                                    caption))
+            time.sleep(hold / self.speed)
+
+    def bars(self, label: str, rows: list[tuple[str, int]], caption: str = "", hold: float = 2.6) -> None:
+        if not self.animate or not rows:
+            return
+        mx = max(v for _, v in rows) or 1
+        w = max(10, min(46, self.c.size.width - 40))
+        nw = max(len(n) for n, _ in rows)
+        with Live(self._panel(label, Text("")), console=self.c, refresh_per_second=40, transient=True,
+                  screen=True) as live:
+            for step in range(1, 21):
+                t = Text(justify="left")
+                for name, v in rows:
+                    n = round(w * v / mx * step / 20)
+                    t.append(f"{name:>{nw}}  ", style="bold #f5f3ff")
+                    t.append("█" * n, style=self.accent)
+                    t.append(f" {round(v * step / 20):,}\n", style="#a09cbe")
+                live.update(self._panel(label, Align.center(t), caption if step == 20 else ""))
+                time.sleep(0.025 / self.speed)
+            time.sleep(hold / self.speed)

shellwrapped/stats.py

@@ -0,0 +1,231 @@
+"""Turn shell history into a year in review."""
+from __future__ import annotations
+
+import math
+import re
+import shlex
+import shutil
+from collections import Counter
+from dataclasses import dataclass, field
+from datetime import date, datetime, timedelta
+
+from .history import Command
+
+# Common fat-fingers -> what was meant.
+TYPOS = {
+    "gti": "git", "got": "git", "gut": "git", "igt": "git", "tgi": "git", "gi": "git", "gitp": "git",
+    "sl": "ls", "l": "ls", "lls": "ls", "ks": "ls", "cd..": "cd ..", "cd-": "cd -", "dc": "cd",
+    "claer": "clear", "clera": "clear", "cler": "clear", "celar": "clear", "exti": "exit", "eixt": "exit",
+    "exi": "exit", "sudp": "sudo", "suod": "sudo", "sduo": "sudo", "grpe": "grep", "gerp": "grep", "rgep": "grep",
+    "pyhton": "python", "pytohn": "python", "pyton": "python", "phyton": "python", "pytho": "python",
+    "pthon": "python", "pyhton3": "python3", "pythno": "python", "nmp": "npm", "npn": "npm", "mpm": "npm",
+    "nom": "npm", "dokcer": "docker", "docekr": "docker", "dcoker": "docker", "kubeclt": "kubectl",
+    "kubctl": "kubectl", "kuebctl": "kubectl", "vmi": "vim", "ivm": "vim", "cim": "vim", "nivm": "nvim",
+    "nvmi": "nvim", "mkdri": "mkdir", "mkidr": "mkdir", "mdkir": "mkdir", "tocuh": "touch", "touhc": "touch",
+    "brwe": "brew", "berw": "brew", "carog": "cargo", "cargp": "cargo", "yran": "yarn", "ymal": "yaml",
+    "pnmp": "pnpm", "code.": "code .", "ssj": "ssh", "shh": "ssh", "mv-": "mv", "car": "cat", "cta": "cat",
+}
+
+CATEGORIES = {
+    "git": "git", "gh": "git", "lazygit": "git", "tig": "git",
+    "docker": "containers", "docker-compose": "containers", "podman": "containers", "kubectl": "containers",
+    "k9s": "containers", "helm": "containers", "minikube": "containers", "kind": "containers",
+    "python": "python", "python3": "python", "pip": "python", "pip3": "python", "uv": "python", "uvx": "python",
+    "poetry": "python", "pytest": "python", "ipython": "python", "jupyter": "python", "conda": "python",
+    "node": "javascript", "npm": "javascript", "npx": "javascript", "pnpm": "javascript", "yarn": "javascript",
+    "bun": "javascript", "deno": "javascript", "tsc": "javascript",
+    "cargo": "rust", "rustc": "rust", "rustup": "rust", "go": "go",
+    "vim": "editors", "nvim": "editors", "vi": "editors", "nano": "editors", "emacs": "editors", "code": "editors",
+    "cursor": "editors", "hx": "editors", "micro": "editors", "subl": "editors",
+    "aws": "cloud", "gcloud": "cloud", "az": "cloud", "terraform": "cloud", "tofu": "cloud", "pulumi": "cloud",
+    "flyctl": "cloud", "vercel": "cloud", "wrangler": "cloud",
+    "cd": "navigation", "ls": "navigation", "ll": "navigation", "la": "navigation", "pwd": "navigation",
+    "tree": "navigation", "z": "navigation", "zoxide": "navigation", "eza": "navigation", "exa": "navigation",
+    "ssh": "remote", "scp": "remote", "rsync": "remote", "mosh": "remote",
+}
+
+PERSONAS = {
+    "git": ("The Git Whisperer", "Version control is your love language."),
+    "containers": ("The Container Captain", "If it doesn't run in Docker, does it run at all?"),
+    "python": ("The Pythonista", "import antigravity, every single day."),
+    "javascript": ("The JS Juggler", "node_modules is, technically, your home directory."),
+    "rust": ("The Rustacean", "The borrow checker and you are on a first-name basis."),
+    "go": ("The Gopher", "if err != nil, you'll handle it."),
+    "editors": ("The Editor Devotee", "You live in your editor and visit the shell."),
+    "cloud": ("The Cloud Wrangler", "Your infrastructure has more commands than your apps."),
+    "navigation": ("The Navigator", "cd, ls, cd, ls. You always know where you are."),
+    "remote": ("The Remote Operator", "Your laptop is mostly a window into other machines."),
+}
+
+SEGMENT = re.compile(r"\s*(?:\|\||&&|\||;)\s*")
+WRAPPERS = {"sudo", "doas", "time", "nohup", "env", "exec", "command", "builtin", "noglob", "caffeinate", "watch"}
+SECRETISH = re.compile(r"[A-Za-z0-9_\-+/=]{20,}")
+
+
+def redact(cmd: str) -> str:
+    """Hide anything that looks like a token or password before a command is ever displayed."""
+    cmd = re.sub(r"(://[^:/\s@]+:)[^@\s]+@", r"\1•••@", cmd)
+    cmd = re.sub(r"(?i)((?:token|key|secret|password|passwd|auth)[\w-]*\s*[=:]\s*)\S+", r"\1•••", cmd)
+
+    def hide(m):
+        s = m.group(0)
+        counts = {c: s.count(c) for c in set(s)}
+        ent = -sum(n / len(s) * math.log2(n / len(s)) for n in counts.values())
+        return s[:4] + "•••" if ent > 3.6 and any(c.isdigit() for c in s) and any(c.isalpha() for c in s) else s
+    return SECRETISH.sub(hide, cmd)
+
+
+def programs(cmd: str) -> list[str]:
+    """The program run by each segment of a command line (`sudo` and friends unwrapped)."""
+    out = []
+    for seg in SEGMENT.split(cmd.strip()):
+        try:
+            words = shlex.split(seg, posix=True)
+        except ValueError:
+            words = seg.split()
+        while words:  # strip FOO=bar assignments and wrappers like sudo/env/time, in any order
+            if "=" in words[0] and not words[0].startswith("="):
+                words = words[1:]
+            elif words[0] in WRAPPERS:
+                words = words[1:]
+                while words and words[0].startswith("-"):
+                    words = words[1:]
+            else:
+                break
+        if words:
+            out.append(words[0].rsplit("/", 1)[-1])
+    return out
+
+
+@dataclass
+class Wrapped:
+    year: int | None
+    commands: int = 0
+    unique: int = 0
+    has_time: bool = False
+    shells: list[str] = field(default_factory=list)
+    top: list[tuple[str, int]] = field(default_factory=list)
+    top_line: tuple[str, int] | None = None
+    git: list[tuple[str, int]] = field(default_factory=list)
+    categories: list[tuple[str, int]] = field(default_factory=list)
+    typos: list[tuple[str, str, int]] = field(default_factory=list)  # (typed, meant, count)
+    typo_total: int = 0
+    sudo: int = 0
+    sudo_bang: int = 0
+    force_push: int = 0
+    rm_rf: int = 0
+    clears: int = 0
+    cd_ls: int = 0
+    longest: int = 0
+    pipes_record: int = 0
+    active_days: int = 0
+    busiest_day: date | None = None
+    busiest_day_count: int = 0
+    peak_hour: int | None = None
+    night_share: float = 0.0
+    longest_session_min: int = 0
+    by_hour: list[int] = field(default_factory=lambda: [0] * 24)
+    persona: tuple[str, str] = ("The Generalist", "A little bit of everything.")
+
+
+def compute(commands: list[Command], year: int | None) -> Wrapped:
+    timed = [c for c in commands if c.when is not None]
+    if year is not None and timed:
+        commands = [c for c in commands if c.when is not None and c.when.year == year]
+        timed = commands
+    w = Wrapped(year=year if timed else None)
+    if not commands:
+        return w
+    w.commands = len(commands)
+    w.shells = sorted({c.shell for c in commands})
+    lines = [c.text.strip() for c in commands]
+    w.unique = len(set(lines))
+
+    progs: Counter[str] = Counter()
+    git_sub: Counter[str] = Counter()
+    typo_hits: Counter[str] = Counter()
+    prev_cd = False
+    for line in lines:
+        ps = programs(line)
+        progs.update(ps)
+        low = line.lower()
+        first = line.split()[0] if line.split() else ""
+        if first in TYPOS and shutil.which(first) is None:
+            typo_hits[first] += 1
+        elif low.strip() in TYPOS:  # e.g. "cd.." typed literally, without the space
+            typo_hits[low.strip()] += 1
+        if re.match(r"^\s*(sudo|doas)\s", line):
+            w.sudo += 1
+        if re.match(r"^\s*sudo\s+!!", line):
+            w.sudo_bang += 1
+        if re.search(r"\bgit\s+push\b.*(--force\b|-f\b|--force-with-lease)", line):
+            w.force_push += 1
+        if re.search(r"\brm\s+-(rf|fr|Rf|fR)\b", line):
+            w.rm_rf += 1
+        if ps[:1] == ["clear"] or line in ("cls", "reset"):
+            w.clears += 1
+        if prev_cd and ps[:1] in (["ls"], ["ll"], ["la"], ["eza"], ["exa"]):
+            w.cd_ls += 1
+        prev_cd = ps[:1] == ["cd"]
+        if "git" in ps:
+            m = re.search(r"\bgit\s+(?:-C\s+\S+\s+)?([a-z][a-z-]*)", line)
+            if m:
+                git_sub[m.group(1)] += 1
+        w.longest = max(w.longest, len(line))
+        w.pipes_record = max(w.pipes_record, line.count("|") - 2 * line.count("||"))
+
+    w.top = progs.most_common(10)
+    line_counts = Counter(l for l in lines if len(l) > 2)
+    if line_counts:
+        top_line, n = line_counts.most_common(1)[0]
+        w.top_line = (redact(top_line), n)
+    w.git = git_sub.most_common(5)
+    cats: Counter[str] = Counter()
+    for p, n in progs.items():
+        if p in CATEGORIES:
+            cats[CATEGORIES[p]] += n
+    w.categories = cats.most_common()
+    w.typos = [(t, TYPOS[t], n) for t, n in typo_hits.most_common(5)]
+    w.typo_total = sum(typo_hits.values())
+
+    if timed:
+        w.has_time = True
+        per_day = Counter(c.when.date() for c in timed)
+        w.active_days = len(per_day)
+        w.busiest_day, w.busiest_day_count = max(per_day.items(), key=lambda kv: (kv[1], kv[0]))
+        for c in timed:
+            w.by_hour[c.when.hour] += 1
+        w.peak_hour = w.by_hour.index(max(w.by_hour))
+        w.night_share = sum(w.by_hour[h] for h in (22, 23, 0, 1, 2, 3, 4)) / len(timed)
+        w.longest_session_min = longest_session(sorted(c.when for c in timed))
+
+    w.persona = persona(w)
+    return w
+
+
+def longest_session(times: list[datetime], gap: timedelta = timedelta(minutes=30)) -> int:
+    if not times:
+        return 0
+    best = 0
+    start = prev = times[0]
+    for t in times[1:]:
+        if t - prev > gap:
+            start = t
+        prev = t
+        best = max(best, int((t - start).total_seconds() // 60))
+    return best
+
+
+def persona(w: Wrapped) -> tuple[str, str]:
+    if w.has_time and w.night_share >= 0.3:
+        return ("The Night Shell", f"{w.night_share:.0%} of your commands ran between 10pm and 5am.")
+    if w.commands and w.typo_total / w.commands >= 0.02:
+        return ("The Speed Typist", f"{w.typo_total} typos. You type faster than you spell.")
+    if w.categories:
+        total = sum(n for _, n in w.categories)
+        cat, n = w.categories[0]
+        if cat == "navigation" and len(w.categories) > 1 and n / total < 0.5:
+            cat = w.categories[1][0]  # everyone cd's; prefer a more telling trait unless it's extreme
+        if cat in PERSONAS:
+            return PERSONAS[cat]
+    return ("The Generalist", "A little bit of everything.")

shellwrapped-0.1.0.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.5
+Name: shellwrapped
+Version: 0.1.0
+Summary: Spotify Wrapped for your terminal: your shell history's year in review, with a shareable card
+Project-URL: Homepage, https://github.com/ArkaKhorchidian/shellwrapped
+Project-URL: Issues, https://github.com/ArkaKhorchidian/shellwrapped/issues
+Author: Arka Khorchidian
+License-Expression: MIT
+License-File: LICENSE
+License-File: src/shellwrapped/fonts/OFL.txt
+Keywords: bash,cli,fish,fun,history,shell,terminal,wrapped,year-in-review,zsh
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Shells
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: pillow>=9.2
+Requires-Dist: pyfiglet>=0.8
+Requires-Dist: rich>=13
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+<h1 align="center">shellwrapped</h1>
+
+<p align="center"><b>Spotify Wrapped for your terminal.</b><br>
+Your shell history's year in review: top commands, git habits, typos, 2am sessions, and your terminal personality. Plus a card to share.</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/shellwrapped/"><img src="https://img.shields.io/pypi/v/shellwrapped.svg" alt="PyPI"></a>
+  <a href="https://github.com/ArkaKhorchidian/shellwrapped/actions/workflows/ci.yml"><img src="https://github.com/ArkaKhorchidian/shellwrapped/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <img src="https://img.shields.io/pypi/pyversions/shellwrapped.svg" alt="Python">
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT"></a>
+</p>
+
+```bash
+uvx shellwrapped        # or: pipx run shellwrapped
+```
+
+<p align="center">
+  <img src="docs/demo.gif" alt="shellwrapped playing an animated year in review in the terminal" width="720">
+</p>
+
+When it's done, you get a card like this saved next to you:
+
+<p align="center"><img src="docs/card.png" alt="shellwrapped share card: The Night Shell" width="720"></p>
+
+<sub>Demo and card generated from a synthetic year of history.</sub>
+
+## What it finds
+
+- **Your top commands**, counted properly through pipes, `&&`, `sudo`, `env` and `VAR=value` prefixes
+- **Your git habits**: how many `git status` it takes you to feel safe
+- **Your most-repeated command**: a strong hint it deserves an alias
+- **Your typos**: `gti`, `sl`, `claer`, `pyhton`, `cd..`, and friends
+- **When you work**: your rush hour, your longest session, your busiest day, how much happens after 10pm
+- **Habits**: `sudo !!`, `rm -rf`, `git push --force`, `cd` immediately followed by `ls`
+- **Your terminal personality**: The Night Shell, The Git Whisperer, The Container Captain, The Pythonista, The Speed Typist, ...
+
+Works with **zsh, bash, fish and PowerShell** on macOS, Linux and Windows. It finds your history files
+automatically, including zsh's extended format with multi-line commands.
+
+## Private by design
+
+- Everything runs locally. No network requests.
+- The share card shows only counts and program names (`git`, `docker`), never full commands, paths or arguments.
+- Anything token-shaped is masked before a command is shown in your terminal.
+
+## Options
+
+```bash
+shellwrapped --all-time            # your whole history instead of this year
+shellwrapped --year 2025
+shellwrapped --no-anim             # skip the animation, just the summary
+shellwrapped --file ~/.zsh_history --shell zsh
+shellwrapped --card wrapped.png    # where to save the card (or --no-card)
+```
+
+Year-by-year stats need timestamps in your history. zsh's `EXTENDED_HISTORY` and fish record
+them automatically. In bash, add `export HISTTIMEFORMAT='%F %T '` to your `.bashrc`. Without timestamps,
+shellwrapped covers everything your history remembers.
+
+## License
+
+MIT. Bundles the [Inter](https://github.com/rsms/inter) typeface under the SIL Open Font License.

shellwrapped-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+shellwrapped/__init__.py,sha256=SSoOXvswayx3ItLi20JKsun8u3NQUW59JNLN5RPRGYQ,82
+shellwrapped/__main__.py,sha256=yQP0sf-rkTO-3MOotv4blvukvNGwbJFz10hQhMsxcJM,28
+shellwrapped/card.py,sha256=ri9X-h1C9lqdeaQdyXAfpuAjScu01JXSPgEzKNdnNcI,3944
+shellwrapped/cli.py,sha256=8KuOSLU953AgCpk09GXEiPKzMhRa44RkSfDZKalVZ0Q,6936
+shellwrapped/history.py,sha256=uJVsNOaLOeJNUJFjaAStWUi4w_yjaoj-EWkuMV9CcSw,4818
+shellwrapped/show.py,sha256=Vn8bh-UW34jBMoeyoOqU6RsVqsmJUBanC7gqcU7B9HQ,5206
+shellwrapped/stats.py,sha256=9lEhYINhDw0m7stS0g_v-LwS8H-Bi9DRIsZyHkZ7yuc,10489
+shellwrapped/fonts/Inter-Bold.otf,sha256=AP1vRpHuiISjO0a_RYUbNBknw3wwBk9VjhvvskKXHEk,626056
+shellwrapped/fonts/Inter-Regular.otf,sha256=vm1wnctzDdrwUMva5v6JvVbV0U3GaIVjm79vBr0DUhs,605092
+shellwrapped/fonts/InterDisplay-Black.otf,sha256=wOu2dpM6Rdc9Fv6nDIdfnytxG1hcabFZYrfyqJC1-Og,617468
+shellwrapped/fonts/OFL.txt,sha256=DxohhtfdVQS2KAiP-zWeMnb-CGS_A5qE4QwLedvy0vo,4163
+shellwrapped-0.1.0.dist-info/METADATA,sha256=XpqUxihJw27i-jCeI_IoB3bGP7lXhdn2it60b4oOmEo,3979
+shellwrapped-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+shellwrapped-0.1.0.dist-info/entry_points.txt,sha256=QsSaEqYCcPcVEfsUBLQLrUE2Q1WqKghqHNjbtiq382Y,54
+shellwrapped-0.1.0.dist-info/licenses/LICENSE,sha256=mxFQpL6plnvuVMkJNW-M1_rxIlAzORcfDhnP1UETuKI,1073
+shellwrapped-0.1.0.dist-info/licenses/src/shellwrapped/fonts/OFL.txt,sha256=DxohhtfdVQS2KAiP-zWeMnb-CGS_A5qE4QwLedvy0vo,4163
+shellwrapped-0.1.0.dist-info/RECORD,,

shellwrapped-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

shellwrapped-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+shellwrapped = shellwrapped.cli:run

shellwrapped-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arka Khorchidian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

shellwrapped-0.1.0.dist-info/licenses/src/shellwrapped/fonts/OFL.txt

@@ -0,0 +1,88 @@
+Inter font: Copyright (c) 2016-2023 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font
+creation efforts of academic and linguistic communities, and to
+provide a free and open framework in which fonts may be shared and
+improved in partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any
+reserved names are not used by derivative works. The fonts and
+derivatives, however, cannot be released under any other type of
+license. The requirement for fonts to remain under this license
+does not apply to any document created using the fonts or their
+derivatives.
+
+DEFINITIONS
+Font Software refers to the set of files released by the
+Copyright Holder(s) under this license and clearly marked as such.
+This may include source files, build scripts and documentation.
+
+Reserved Font Name refers to any names specified as such after
+the copyright statement(s).
+
+Original Version refers to the collection of Font Software
+components as distributed by the Copyright Holder(s).
+
+Modified Version refers to any derivative made by adding to,
+deleting, or substituting in part or in whole any of the components
+of the Original Version, by changing formats or by porting the Font
+Software to a new environment.
+
+Author refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of the Font Software, to use, study, copy, merge,
+embed, modify, redistribute, and sell modified and unmodified copies
+of the Font Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+   in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+   redistributed and/or sold with any software, provided that each
+   copy contains the above copyright notice and this license. These
+   can be included either as stand-alone text files, human-readable
+   headers or in the appropriate machine-readable metadata fields
+   within text or binary files as long as those fields can be easily
+   viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+   Name(s) unless explicit written permission is granted by the
+   corresponding Copyright Holder. This restriction only applies to
+   the primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the
+   Font Software shall not be used to promote, endorse or advertise
+   any Modified Version, except to acknowledge the contribution(s)
+   of the Copyright Holder(s) and the Author(s) or with their
+   explicit written permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+   must be distributed entirely under this license, and must not be
+   distributed under any other license. The requirement for fonts to
+   remain under this license does not apply to any document created
+   using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions
+are not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL
+THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR
+CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT
+SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.