codewrapped 0.1.0__py3-none-any.whl

codewrapped/__init__.py

@@ -0,0 +1,2 @@
+"""codewrapped: Spotify Wrapped for your code."""
+__version__ = "0.1.0"

codewrapped/__main__.py

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

codewrapped/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

codewrapped/cli.py

@@ -0,0 +1,140 @@
+"""codewrapped: Spotify Wrapped for your code, from the git history on your machine."""
+from __future__ import annotations
+
+import argparse
+import subprocess
+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 . import __version__, card
+from .collect import collect, is_repo
+from .show import Story
+from .stats import Wrapped, clock12, compute
+
+ACCENT = "#7c6cff"
+
+
+def human(n: int) -> str:
+    return f"{n / 1_000_000:.1f}M" if n >= 1_000_000 else f"{n / 1000:.1f}k" if n >= 10_000 else f"{n:,}"
+
+
+def story(w: Wrapped, s: Story) -> None:
+    s.words("codewrapped", f"Your {w.year} in code", "Reading your git history. Nothing leaves this machine.",
+            hold=1.8)
+    s.number("commits", w.commits, f"across {w.repos} repo{'s' if w.repos != 1 else ''}, on {w.active_days} days")
+    s.number("lines added", w.added, f"and {w.deleted:,} deleted. Net {w.added - w.deleted:+,}.")
+    if w.longest_streak > 1:
+        s.number("day streak", w.longest_streak,
+                 f"{w.streak_start:%b} {w.streak_start.day} to {w.streak_end:%b} {w.streak_end.day}, without a day off")
+    if w.languages:
+        s.bars("your languages, by lines written", [(l, n) for l, n in w.languages], f"Mostly {w.languages[0][0]}.")
+    if len(w.top_repos) > 1:
+        s.bars("where your commits went", w.top_repos, f"{w.top_repos[0][0]} got the most love")
+    s.words("you code best at", f"{clock12(w.peak_hour)} on {w.peak_weekday}s",
+            f"Busiest day: {w.busiest_day:%B} {w.busiest_day.day}, {w.busiest_day_commits} commits"
+            + (f". Busiest month: {w.busiest_month}." if w.busiest_month else ""))
+    if w.latest_commit:
+        t, subject, repo = w.latest_commit
+        s.words("your latest-night commit", t, f'"{subject[:70]}" in {repo}')
+    if w.top_word:
+        s.words("your favorite word in commit messages", w.top_word, f"{w.top_word_count} times"
+                + (f". Plus {w.fix_commits} commits that were fixes." if w.fix_commits else ""))
+    if w.persona:
+        s.words("your developer personality", w.persona.title, w.persona.line, hold=3.0)
+
+
+def summary(w: Wrapped) -> Panel:
+    t = Table.grid(padding=(0, 3))
+    t.add_column(style="#a09cbe", justify="right")
+    t.add_column(style="bold #f5f3ff")
+    t.add_row("commits", f"{w.commits:,}  [#a09cbe]in {w.repos} repos · {w.active_days} active days[/]")
+    t.add_row("lines", f"[#3fd17a]+{w.added:,}[/] [#ff5c6c]-{w.deleted:,}[/]  [#a09cbe]{w.files:,} files touched[/]")
+    t.add_row("longest streak", f"{w.longest_streak} days" + (
+        f"  [#a09cbe]{w.streak_start} → {w.streak_end}[/]" if w.longest_streak > 1 else ""))
+    if w.languages:
+        t.add_row("languages", "  ".join(f"{l} [#a09cbe]{human(n)}[/]" for l, n in w.languages))
+    if w.top_repos:
+        t.add_row("top repos", "  ".join(f"{r} [#a09cbe]{n}[/]" for r, n in w.top_repos[:4]))
+    t.add_row("rhythm", f"{clock12(w.peak_hour)} · {w.peak_weekday}s · {w.busiest_month}  "
+                        f"[#a09cbe]{w.night_share:.0%} at night · {w.weekend_share:.0%} weekends[/]")
+    if w.biggest_commit:
+        t.add_row("biggest commit", f"{w.biggest_commit[0][:60]}  [#a09cbe]{w.biggest_commit[1]:,} lines · "
+                                    f"{w.biggest_commit[2]}[/]")
+    if w.shortest_message:
+        t.add_row("shortest message", f'"{w.shortest_message}"')
+    if w.persona:
+        t.add_row("personality", f"[{ACCENT}]{w.persona.title}[/]  [#a09cbe]{w.persona.line}[/]")
+    return Panel(t, title=f"[bold {ACCENT}]codewrapped[/] [#a09cbe]{w.year}[/]", title_align="left",
+                 border_style=ACCENT, padding=(1, 2))
+
+
+def make_card(w: Wrapped, path: Path) -> Path:
+    stats = [("commits", f"{w.commits:,}"), ("lines added", human(w.added)),
+             ("day streak", f"{w.longest_streak}"), ("active days", f"{w.active_days}")]
+    # repo names can be private work projects, so the card only shows languages
+    return card.render(path, brand="codewrapped", year_label=str(w.year), persona=w.persona.title,
+                       tagline=w.persona.line, stats=stats, bars=w.languages, bars_title="languages",
+                       footer="uvx codewrapped", accent=(124, 108, 255), top=(18, 16, 44), bottom=(8, 8, 20))
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(prog="codewrapped",
+                                description="Spotify Wrapped for your code: your year in commits, from every git "
+                                            "repo on your machine. Nothing leaves your computer.")
+    p.add_argument("paths", nargs="*", type=Path, help="repos or folders to search for repos (default: here)")
+    p.add_argument("--year", type=int, default=date.today().year)
+    p.add_argument("--author", action="append", help="email or name to count as you (repeatable; default: "
+                                                     "your git config)")
+    p.add_argument("--everyone", action="store_true", help="include every author (a whole team's wrapped)")
+    p.add_argument("--depth", type=int, default=5, help="how deep to look for repos (default 5)")
+    p.add_argument("--no-anim", action="store_true")
+    p.add_argument("--speed", type=float, default=1.0)
+    p.add_argument("--card", type=Path, help="share card path (default ./codewrapped-<year>.png)")
+    p.add_argument("--no-card", action="store_true")
+    p.add_argument("--version", action="version", version=f"codewrapped {__version__}")
+    a = p.parse_args(argv)
+    console = Console()
+    roots = a.paths or [Path.cwd()]
+    if not any(is_repo(r) for r in roots) and roots == [Path.cwd()] and Path.cwd() == Path.home():
+        console.print("[#a09cbe]Searching your whole home folder for repos. Point me at your code folder to be "
+                      "faster: codewrapped ~/code[/]")
+    with console.status("[#a09cbe]reading git history…[/]", spinner="dots"):
+        commits, repos, ids = collect(roots, a.year, a.author, a.everyone, a.depth)
+    if not repos:
+        console.print("No git repositories found here. Try: codewrapped ~/code")
+        return 1
+    if not commits:
+        who = ", ".join(sorted(ids)) or "(no git identity configured)"
+        console.print(f"Found {len(repos)} repos but no {a.year} commits by {who}.\n"
+                      "Add the emails you commit with: codewrapped --author you@work.com --author you@home.com")
+        return 1
+    name = subprocess.run(["git", "config", "--global", "user.name"], capture_output=True, text=True).stdout.strip()
+    w = compute(commits, a.year, name)
+    if not a.no_anim and console.is_terminal:
+        try:
+            story(w, Story(console, ACCENT, a.speed))
+        except KeyboardInterrupt:
+            pass
+    console.print(summary(w))
+    if not a.no_card:
+        out = a.card or Path(f"codewrapped-{a.year}.png")
+        try:
+            make_card(w, out)
+            console.print(f"\n[bold {ACCENT}]Share card saved:[/] {out}  [#a09cbe](no repo names or code on it, "
+                          f"just your numbers and languages)[/]")
+        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()

codewrapped/collect.py

@@ -0,0 +1,123 @@
+"""Find git repositories and read one person's commits for a year. Everything stays local."""
+from __future__ import annotations
+
+import os
+import subprocess
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Iterable, Iterator
+
+SKIP_DIRS = {
+    "node_modules", ".venv", "venv", "env", ".tox", ".cache", "__pycache__", "target", "build", "dist",
+    "Library", "Applications", ".Trash", "AppData", ".npm", ".cargo", ".rustup", ".pyenv", ".nvm",
+    "vendor", "Pods", "DerivedData", ".gradle", ".m2", "site-packages", ".local", ".git",
+}
+
+RS, US = "\x1e", "\x1f"  # record / unit separators keep commit messages unambiguous
+
+
+@dataclass
+class Commit:
+    sha: str
+    repo: str
+    email: str
+    name: str
+    when: datetime  # author time, in the author's own timezone
+    subject: str
+    files: list[tuple[str, int, int]] = field(default_factory=list)  # (path, added, deleted)
+
+
+def _git(repo: Path, *args: str) -> str:
+    out = subprocess.run(["git", "-C", str(repo), *args], capture_output=True, text=True,
+                         encoding="utf-8", errors="replace")
+    return out.stdout if out.returncode == 0 else ""
+
+
+def is_repo(path: Path) -> bool:
+    return (path / ".git").exists()
+
+
+def find_repos(roots: Iterable[Path], max_depth: int = 5) -> list[Path]:
+    """Walk `roots` for git repositories (not descending into a repo once found)."""
+    found: list[Path] = []
+    for root in roots:
+        root = root.expanduser().resolve()
+        if is_repo(root):
+            found.append(root)
+            continue
+        base_depth = len(root.parts)
+        for dirpath, dirnames, _ in os.walk(root, onerror=lambda e: None):
+            here = Path(dirpath)
+            if is_repo(here):
+                found.append(here)
+                dirnames[:] = []
+                continue
+            if len(here.parts) - base_depth >= max_depth:
+                dirnames[:] = []
+                continue
+            dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS and not (d.startswith(".") and d != ".config")]
+    seen, unique = set(), []
+    for r in found:
+        if r not in seen:
+            seen.add(r)
+            unique.append(r)
+    return unique
+
+
+def my_identities(repos: list[Path]) -> set[str]:
+    """Emails and names from global git config plus each repo's local config."""
+    ids: set[str] = set()
+    for key in ("user.email", "user.name"):
+        v = subprocess.run(["git", "config", "--global", key], capture_output=True, text=True).stdout.strip()
+        if v:
+            ids.add(v.lower())
+    for r in repos:
+        for key in ("user.email", "user.name"):
+            v = _git(r, "config", "--local", key).strip()
+            if v:
+                ids.add(v.lower())
+    return ids
+
+
+def read_commits(repo: Path, year: int, identities: set[str] | None) -> Iterator[Commit]:
+    """Non-merge commits from all refs, authored in `year`, by anyone in `identities` (None = everyone)."""
+    fmt = f"{RS}%H{US}%ae{US}%an{US}%aI{US}%s"
+    log = _git(repo, "log", "--all", "--no-merges", "--numstat", "--no-renames",
+               f"--since={year - 1}-12-30", f"--until={year + 1}-01-02", f"--format={fmt}")
+    name = repo.name
+    for block in log.split(RS)[1:]:
+        head, _, rest = block.partition("\n")
+        parts = head.split(US)
+        if len(parts) < 5:
+            continue
+        sha, email, author, iso, subject = parts[0], parts[1], parts[2], parts[3], US.join(parts[4:])
+        try:
+            when = datetime.fromisoformat(iso)
+        except ValueError:
+            continue
+        if when.year != year:  # author-local calendar year
+            continue
+        if identities is not None and email.lower() not in identities and author.lower() not in identities:
+            continue
+        files = []
+        for line in rest.splitlines():
+            cols = line.split("\t")
+            if len(cols) == 3:
+                a, d, path = cols
+                files.append((path, int(a) if a.isdigit() else 0, int(d) if d.isdigit() else 0))
+        yield Commit(sha, name, email, author, when, subject, files)
+
+
+def collect(roots: list[Path], year: int, authors: list[str] | None = None, everyone: bool = False,
+            max_depth: int = 5) -> tuple[list[Commit], list[Path], set[str]]:
+    repos = find_repos(roots, max_depth=max_depth)
+    if everyone:
+        ids = None
+    else:
+        ids = {a.lower() for a in authors} if authors else my_identities(repos)
+    commits: dict[str, Commit] = {}
+    for r in repos:
+        for c in read_commits(r, year, ids):
+            commits.setdefault(c.sha, c)  # the same commit can live in several clones/forks
+    return sorted(commits.values(), key=lambda c: c.when), repos, ids or set()

codewrapped/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.

codewrapped/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)

codewrapped/stats.py

@@ -0,0 +1,207 @@
+"""Turn commits into a year in review."""
+from __future__ import annotations
+
+import re
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from datetime import date, timedelta
+from pathlib import PurePosixPath
+
+from .collect import Commit
+
+# Generated / vendored files would drown out real work in line counts.
+IGNORED_FILES = re.compile(
+    r"(^|/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|poetry\.lock|Pipfile\.lock|uv\.lock|Cargo\.lock|"
+    r"Gemfile\.lock|composer\.lock|go\.sum|bun\.lockb)$"
+    r"|(^|/)(node_modules|vendor|dist|build|\.next|__snapshots__)/"
+    r"|\.min\.(js|css)$|\.map$|\.(png|jpe?g|gif|svg|ico|pdf|zip|gz|lock|ipynb)$"
+)
+
+LANGUAGES = {
+    "py": "Python", "pyi": "Python", "ipynb": "Python", "js": "JavaScript", "mjs": "JavaScript", "cjs": "JavaScript",
+    "jsx": "JavaScript", "ts": "TypeScript", "tsx": "TypeScript", "go": "Go", "rs": "Rust", "java": "Java",
+    "kt": "Kotlin", "kts": "Kotlin", "swift": "Swift", "c": "C", "h": "C", "cc": "C++", "cpp": "C++", "cxx": "C++",
+    "hpp": "C++", "hh": "C++", "cs": "C#", "rb": "Ruby", "php": "PHP", "scala": "Scala", "dart": "Dart",
+    "lua": "Lua", "r": "R", "jl": "Julia", "ex": "Elixir", "exs": "Elixir", "erl": "Erlang", "hs": "Haskell",
+    "ml": "OCaml", "clj": "Clojure", "zig": "Zig", "nim": "Nim", "sh": "Shell", "bash": "Shell", "zsh": "Shell",
+    "fish": "Shell", "ps1": "PowerShell", "sql": "SQL", "html": "HTML", "htm": "HTML", "css": "CSS", "scss": "CSS",
+    "sass": "CSS", "less": "CSS", "vue": "Vue", "svelte": "Svelte", "md": "Markdown", "mdx": "Markdown",
+    "rst": "reStructuredText", "tex": "LaTeX", "yml": "YAML", "yaml": "YAML", "toml": "TOML", "json": "JSON",
+    "tf": "Terraform", "hcl": "Terraform", "sol": "Solidity", "v": "Verilog", "sv": "Verilog", "vhd": "VHDL",
+    "m": "Objective-C", "mm": "Objective-C", "pl": "Perl", "dockerfile": "Dockerfile", "proto": "Protobuf",
+    "graphql": "GraphQL", "nix": "Nix", "elm": "Elm", "fs": "F#", "cu": "CUDA", "glsl": "GLSL", "wgsl": "WGSL",
+}
+# Config/markup "languages" count toward lines but never headline someone's year.
+SUPPORTING = {"Markdown", "reStructuredText", "YAML", "TOML", "JSON"}
+
+STOPWORDS = set("""a an the and or to of in on for with from by at as is are be it this that into via
+use using add added adds update updated updates fix fixed fixes remove removed make made more less new
+some small minor wip initial commit merge branch main master refactor cleanup clean bump version readme
+docs doc test tests change changes changed improve improved support allow when not no up out get set""".split())
+
+WEEKDAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+
+
+def language_of(path: str) -> str | None:
+    p = PurePosixPath(path)
+    if p.name.lower() == "dockerfile":
+        return "Dockerfile"
+    return LANGUAGES.get(p.suffix.lower().lstrip("."))
+
+
+@dataclass
+class Persona:
+    title: str
+    line: str
+
+
+@dataclass
+class Wrapped:
+    year: int
+    name: str
+    commits: int = 0
+    repos: int = 0
+    active_days: int = 0
+    added: int = 0
+    deleted: int = 0
+    files: int = 0
+    longest_streak: int = 0
+    streak_start: date | None = None
+    streak_end: date | None = None
+    busiest_day: date | None = None
+    busiest_day_commits: int = 0
+    busiest_month: str = ""
+    peak_hour: int = 0
+    peak_weekday: str = ""
+    night_share: float = 0.0
+    weekend_share: float = 0.0
+    heatmap: list[list[int]] = field(default_factory=lambda: [[0] * 24 for _ in range(7)])
+    by_month: list[int] = field(default_factory=lambda: [0] * 12)
+    languages: list[tuple[str, int]] = field(default_factory=list)  # (language, lines added)
+    top_repos: list[tuple[str, int]] = field(default_factory=list)
+    top_word: str | None = None
+    top_word_count: int = 0
+    fix_commits: int = 0
+    shortest_message: str | None = None
+    biggest_commit: tuple[str, int, str] | None = None  # (subject, lines, repo)
+    latest_commit: tuple[str, str, str] | None = None  # (time, subject, repo) of the latest-night commit
+    persona: Persona | None = None
+
+
+def clock12(hour: int, minute: int | None = None) -> str:
+    h = (hour % 12) or 12
+    return f"{h}{'' if minute is None else f':{minute:02d}'} {'am' if hour < 12 else 'pm'}"
+
+
+def longest_run(days: list[date]) -> tuple[int, date | None, date | None]:
+    if not days:
+        return 0, None, None
+    best = (1, days[0], days[0])
+    start = prev = days[0]
+    for d in days[1:]:
+        if d - prev == timedelta(days=1):
+            if (d - start).days + 1 > best[0]:
+                best = ((d - start).days + 1, start, d)
+        else:
+            start = d
+        prev = d
+    return best
+
+
+def compute(commits: list[Commit], year: int, name: str = "") -> Wrapped:
+    w = Wrapped(year=year, name=name)
+    if not commits:
+        return w
+    w.commits = len(commits)
+    w.repos = len({c.repo for c in commits})
+
+    per_day = Counter(c.when.date() for c in commits)
+    days = sorted(per_day)
+    w.active_days = len(days)
+    w.longest_streak, w.streak_start, w.streak_end = longest_run(days)
+    w.busiest_day, w.busiest_day_commits = max(per_day.items(), key=lambda kv: (kv[1], kv[0]))
+
+    for c in commits:
+        w.heatmap[c.when.weekday()][c.when.hour] += 1
+        w.by_month[c.when.month - 1] += 1
+    w.busiest_month = date(year, w.by_month.index(max(w.by_month)) + 1, 1).strftime("%B")
+    hours = [sum(w.heatmap[d][h] for d in range(7)) for h in range(24)]
+    w.peak_hour = hours.index(max(hours))
+    weekdays = [sum(row) for row in w.heatmap]
+    w.peak_weekday = WEEKDAYS[weekdays.index(max(weekdays))]
+    w.night_share = sum(hours[h] for h in (22, 23, 0, 1, 2, 3, 4)) / w.commits
+    w.weekend_share = (weekdays[5] + weekdays[6]) / w.commits
+
+    langs: Counter[str] = Counter()
+    files = set()
+    biggest = None
+    for c in commits:
+        size = 0
+        for path, a, d in c.files:
+            if IGNORED_FILES.search(path):
+                continue
+            files.add((c.repo, path))
+            w.added += a
+            w.deleted += d
+            size += a + d
+            lang = language_of(path)
+            if lang:
+                langs[lang] += a
+        if biggest is None or size > biggest[1]:
+            biggest = (c.subject, size, c.repo)
+    w.files = len(files)
+    w.biggest_commit = biggest if biggest and biggest[1] > 0 else None
+    main = [(l, n) for l, n in langs.most_common() if l not in SUPPORTING and n > 0]
+    w.languages = (main or [(l, n) for l, n in langs.most_common() if n > 0])[:5]
+    w.top_repos = Counter(c.repo for c in commits).most_common(5)
+
+    words: Counter[str] = Counter()
+    for c in commits:
+        s = c.subject.lower()
+        if re.search(r"\b(fix(e[sd])?|bug|hotfix|patch)\b", s):
+            w.fix_commits += 1
+        for tok in re.findall(r"[a-z][a-z0-9_+#-]{2,}", s):
+            if tok not in STOPWORDS:
+                words[tok] += 1
+    if words:
+        w.top_word, w.top_word_count = words.most_common(1)[0]
+    subjects = [c.subject.strip() for c in commits if c.subject.strip()]
+    if subjects:
+        w.shortest_message = min(subjects, key=len)
+
+    def lateness(c: Commit) -> int:  # minutes past 6pm, wrapping past midnight
+        m = c.when.hour * 60 + c.when.minute
+        return m - 18 * 60 if m >= 18 * 60 else m + 6 * 60 if m < 5 * 60 else -1
+    late = max(commits, key=lateness)
+    if lateness(late) >= 0:
+        w.latest_commit = (clock12(late.when.hour, late.when.minute), late.subject, late.repo)
+
+    w.persona = persona(w)
+    return w
+
+
+def persona(w: Wrapped) -> Persona:
+    """Pick the trait that stands out most; each score is how far past its threshold the user is."""
+    avg_per_day = w.commits / max(w.active_days, 1)
+    rules = [
+        (w.night_share / 0.25, "The Night Owl",
+         f"{w.night_share:.0%} of your commits landed between 10pm and 5am."),
+        (w.weekend_share / 0.30, "The Weekend Warrior",
+         f"{w.weekend_share:.0%} of your commits happened on Saturdays and Sundays."),
+        (w.longest_streak / 21, "The Marathoner",
+         f"You committed {w.longest_streak} days in a row."),
+        ((w.deleted / max(w.added, 1)) / 0.8 if w.added > 500 else 0, "The Refactorer",
+         f"You deleted {w.deleted:,} lines. Less code, fewer bugs."),
+        ((w.fix_commits / w.commits) / 0.35 if w.commits >= 20 else 0, "The Bug Hunter",
+         f"{w.fix_commits} of your commits were fixes."),
+        (len([l for l, n in w.languages if n > 0.08 * max(w.added, 1)]) / 4, "The Polyglot",
+         f"You shipped real code in {len(w.languages)} languages."),
+        ((w.busiest_day_commits / avg_per_day) / 6 if w.active_days >= 10 else 0, "The Sprinter",
+         f"On your biggest day you made {w.busiest_day_commits} commits."),
+        ((sum(w.heatmap[d][h] for d in range(7) for h in range(5, 9)) / w.commits) / 0.2,
+         "The Early Bird", "You did your best work before most people's first coffee."),
+    ]
+    score, title, line = max(rules, key=lambda r: r[0])
+    if score < 1:
+        return Persona("The Steady Shipper", f"Commits on {w.active_days} days. Consistency is a superpower.")
+    return Persona(title, line)

codewrapped-0.1.0.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.5
+Name: codewrapped
+Version: 0.1.0
+Summary: Spotify Wrapped for your code: your year in commits across every git repo on your machine, with a shareable card
+Project-URL: Homepage, https://github.com/ArkaKhorchidian/codewrapped
+Project-URL: Issues, https://github.com/ArkaKhorchidian/codewrapped/issues
+Author: Arka Khorchidian
+License-Expression: MIT
+License-File: LICENSE
+License-File: src/codewrapped/fonts/OFL.txt
+Keywords: cli,commits,developer,fun,git,github,stats,wrapped,year-in-review
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+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">codewrapped</h1>
+
+<p align="center"><b>Spotify Wrapped for your code.</b><br>
+Your year in commits, from <i>every</i> git repo on your machine, work and personal, public and private. Plus a card to share.</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/codewrapped/"><img src="https://img.shields.io/pypi/v/codewrapped.svg" alt="PyPI"></a>
+  <a href="https://github.com/ArkaKhorchidian/codewrapped/actions/workflows/ci.yml"><img src="https://github.com/ArkaKhorchidian/codewrapped/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <img src="https://img.shields.io/pypi/pyversions/codewrapped.svg" alt="Python">
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT"></a>
+</p>
+
+```bash
+uvx codewrapped ~/code        # or: pipx run codewrapped ~/code
+```
+
+<p align="center">
+  <img src="docs/demo.gif" alt="codewrapped playing an animated year in review of git history" width="720">
+</p>
+
+<p align="center"><img src="docs/card.png" alt="codewrapped share card: The Marathoner" width="720"></p>
+
+<sub>Demo and card generated from synthetic repositories.</sub>
+
+## Why another Wrapped?
+
+GitHub-based year-in-review tools only see what's on GitHub. Your year also lives in your
+employer's GitLab, in private repos, and in side projects that never got pushed. codewrapped
+reads the git history already on your disk, so it sees all of it, and none of it leaves your
+machine.
+
+## What you get
+
+- **Commits, lines added and deleted, active days, longest streak**, deduplicated across clones and forks
+- **Your languages** by lines written (lockfiles, `node_modules`, minified and generated files are ignored)
+- **Your rhythm**: the hour and weekday you code best, your busiest day and month, your latest-night commit
+- **Your commit messages**: your favorite word, how many were fixes, your shortest message
+- **Your developer personality**: The Night Owl, The Marathoner, The Refactorer, The Weekend Warrior, The Polyglot, ...
+- **A 1200×675 share card**, sized for X, LinkedIn and Slack previews
+
+## Private by design
+
+- It reads your local git history. No API calls, no tokens, no network.
+- **The card never shows repo names or code**, so private work projects stay private. It shows your numbers and languages only.
+- Repo names appear in your terminal summary, which only you see.
+
+## Options
+
+```bash
+codewrapped                         # repos under the current folder
+codewrapped ~/code ~/work           # search several places
+codewrapped --year 2025
+codewrapped --author me@work.com --author me@personal.dev   # all the emails you commit with
+codewrapped --everyone              # a whole team's wrapped, for one repo
+codewrapped --no-anim               # just the summary
+codewrapped --card wrapped.png      # or --no-card
+```
+
+By default it counts commits matching the `user.email` / `user.name` in your git config (global and per-repo).
+If you've committed under several emails, pass each with `--author`.
+
+## License
+
+MIT. Bundles the [Inter](https://github.com/rsms/inter) typeface under the SIL Open Font License.

codewrapped-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+codewrapped/__init__.py,sha256=NNrkb-SxBMMA0SIdkKDYiNj4SFEdiX3MPzG_g-xih8U,72
+codewrapped/__main__.py,sha256=yQP0sf-rkTO-3MOotv4blvukvNGwbJFz10hQhMsxcJM,28
+codewrapped/card.py,sha256=ri9X-h1C9lqdeaQdyXAfpuAjScu01JXSPgEzKNdnNcI,3944
+codewrapped/cli.py,sha256=HTVOUnt7gDxrrdY4Pw0fsGt-4UcKmZNB7Td7YffXmfE,7325
+codewrapped/collect.py,sha256=jxu1c_aY4ePvwSoXPVzzOV8PB8Q873jQk_jd0ze8CUQ,4771
+codewrapped/show.py,sha256=Vn8bh-UW34jBMoeyoOqU6RsVqsmJUBanC7gqcU7B9HQ,5206
+codewrapped/stats.py,sha256=QzTid4xjHbGjxpF7EjKSpdNt2xnP2uXcc9f6YYruglQ,9200
+codewrapped/fonts/Inter-Bold.otf,sha256=AP1vRpHuiISjO0a_RYUbNBknw3wwBk9VjhvvskKXHEk,626056
+codewrapped/fonts/Inter-Regular.otf,sha256=vm1wnctzDdrwUMva5v6JvVbV0U3GaIVjm79vBr0DUhs,605092
+codewrapped/fonts/InterDisplay-Black.otf,sha256=wOu2dpM6Rdc9Fv6nDIdfnytxG1hcabFZYrfyqJC1-Og,617468
+codewrapped/fonts/OFL.txt,sha256=DxohhtfdVQS2KAiP-zWeMnb-CGS_A5qE4QwLedvy0vo,4163
+codewrapped-0.1.0.dist-info/METADATA,sha256=PZqU9xWBepW7dTkAGY_UdbbnHSKWlsJkKSShxDWS_h8,4128
+codewrapped-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+codewrapped-0.1.0.dist-info/entry_points.txt,sha256=2iDw9WCIA4WbPU6XhO2yi4hn_ctgLuUNxD3FcYo9y8w,52
+codewrapped-0.1.0.dist-info/licenses/LICENSE,sha256=mxFQpL6plnvuVMkJNW-M1_rxIlAzORcfDhnP1UETuKI,1073
+codewrapped-0.1.0.dist-info/licenses/src/codewrapped/fonts/OFL.txt,sha256=DxohhtfdVQS2KAiP-zWeMnb-CGS_A5qE4QwLedvy0vo,4163
+codewrapped-0.1.0.dist-info/RECORD,,

codewrapped-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

codewrapped-0.1.0.dist-info/entry_points.txt

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

codewrapped-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.

codewrapped-0.1.0.dist-info/licenses/src/codewrapped/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.