codeannex 0.1.1__py3-none-any.whl

codeannex/__main__.py

@@ -0,0 +1,157 @@
+import argparse
+import io
+import os
+from pathlib import Path
+
+from .config import IMAGE_EXTENSIONS, BINARY_EXTENSIONS, PDFConfig
+from .file_utils import get_project_files, classify_file, sort_files
+from .fonts import init_sprites, register_best_font, register_emoji_font
+from .pdf_builder import ModernAnnexPDF
+from reportlab.lib.units import cm
+
+
+def check_emoji_font_style():
+    """Utility function to check current emoji font style."""
+    from .fonts import register_emoji_font, get_emoji_font_style, is_google_like_emoji_font
+
+    emoji_font = register_emoji_font()
+    if emoji_font:
+        # Tentar obter informações sobre a fonte
+        # Nota: Esta é uma simplificação - em produção teríamos o caminho armazenado
+        print(f"✅ Emoji font registered: {emoji_font}")
+        print("ℹ️  To check if using Google-like style, look for 'Noto' in the font path above")
+        print("💡 Tip: Install Google Noto fonts for authentic Google emoji style")
+    else:
+        print("⚠️  No emoji font found - emojis may not render correctly")
+    return emoji_font
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generates a PDF code annex with Smart Index and Images.")
+    parser.add_argument("dir", nargs="?", default=".", help="Project directory")
+    parser.add_argument("-o", "--output", default=None, help="Output PDF filename")
+    parser.add_argument("-n", "--name", default=None, help="Project name (default: directory name)")
+    parser.add_argument("--margin", type=float, default=None, help="General margin in cm for all sides")
+    parser.add_argument("--margin-left", type=float, default=None, help="Left margin in cm (default: 1.5cm)")
+    parser.add_argument("--margin-right", type=float, default=None, help="Right margin in cm (default: 1.5cm)")
+    parser.add_argument("--margin-top", type=float, default=None, help="Top margin in cm (default: 2.0cm)")
+    parser.add_argument("--margin-bottom", type=float, default=None, help="Bottom margin in cm (default: 2.0cm)")
+    parser.add_argument("--start-page", type=int, default=1, help="Starting page number (default: 1)")
+    parser.add_argument("--show-project", action="store_true", help="Show project name in footer")
+    parser.add_argument("--repo-url", default=None, help="Repository URL to show on cover")
+    parser.add_argument("--page-number-size", type=int, default=8, help="Font size for page numbers (default: 8)")
+    parser.add_argument("--normal-font", default=None, help="Normal text font (default: Helvetica)")
+    parser.add_argument("--bold-font", default=None, help="Bold text font (default: Helvetica-Bold)")
+    parser.add_argument("--mono-font", default=None, help="Monospace font for code (default: auto-detect)")
+    parser.add_argument("--emoji-font", default=None, help="Font for emojis (default: auto-detect)")
+    parser.add_argument("--emoji-description", action="store_true", help="Print [description] instead of emoji glyphs")
+    parser.add_argument("--check-emoji-font", action="store_true", help="Check current emoji font style and exit")
+
+    args, unknown = parser.parse_known_args()
+
+    # Handle unknown arguments
+    if unknown:
+        for u in unknown:
+            if u.startswith("-"):
+                print(f"⚠️  Warning: Unrecognized argument ignored: {u}")
+
+    # Handle emoji font check
+    if args.check_emoji_font:
+        check_emoji_font_style()
+        return
+
+    root   = Path(args.dir).resolve()
+    output = args.output or f"{root.name}_anexo_codigo.pdf"
+
+    script_path = Path(os.path.abspath(__file__))
+    output_path = Path(output).resolve()
+
+    mono_font, is_ttf, ttf_path = register_best_font()
+    # If --emoji-description is NOT set, we MUST have an emoji font or we exit with error
+    emoji_font = register_emoji_font(error_on_missing=not args.emoji_description)
+    init_sprites(is_ttf, ttf_path)
+
+    # Determine margin values (specific margins override general --margin)
+    def get_margin(spec, general, default):
+        if spec is not None:
+            return spec * cm
+        if general is not None:
+            return general * cm
+        return default
+
+    # Criar configuração
+    config = PDFConfig(
+        project_name=args.name or root.name,
+        margin_left=get_margin(args.margin_left, args.margin, PDFConfig().margin_left),
+        margin_right=get_margin(args.margin_right, args.margin, PDFConfig().margin_right),
+        margin_top=get_margin(args.margin_top, args.margin, PDFConfig().margin_top),
+        margin_bottom=get_margin(args.margin_bottom, args.margin, PDFConfig().margin_bottom),
+        start_page_num=args.start_page,
+        show_project_name=args.show_project,
+        normal_font=args.normal_font or PDFConfig().normal_font,
+        bold_font=args.bold_font or PDFConfig().bold_font,
+        mono_font=args.mono_font or mono_font,
+        emoji_font=args.emoji_font or emoji_font,
+        emoji_description=args.emoji_description,
+        repo_url=args.repo_url,
+        page_number_size=args.page_number_size,
+    )
+
+    print(f"🔍 Analyzing directory: {root}")
+    all_files = sort_files(get_project_files(root), root)
+    included  = []
+    ignored_binaries = []
+
+    for fp in all_files:
+        try:
+            if fp.resolve() in (script_path, output_path):
+                continue
+        except Exception:
+            pass
+        if not fp.is_file():
+            continue
+
+        ext = fp.suffix.lower()
+
+        # Check known extensions first (without reading file)
+        if ext == ".svg":
+            included += [(fp, "image"), (fp, "text")]
+            continue
+        elif ext in IMAGE_EXTENSIONS:
+            included.append((fp, "image"))
+            continue
+        elif ext in BINARY_EXTENSIONS:
+            ignored_binaries.append(fp)
+            continue
+
+        # Classify file with a single read
+        file_type = classify_file(fp)
+        if file_type == "text":
+            included.append((fp, "text"))
+        elif file_type == "binary":
+            ignored_binaries.append(fp)
+
+    if ignored_binaries:
+        for bp in ignored_binaries:
+            rel_path = bp.relative_to(root)
+            print(f"⚠️ Ignoring binary file: {rel_path}")
+
+    if not included:
+        print("❌ No compatible files found.")
+        return
+
+    print(f"🧮 Step 1/2: Simulating layout of {len(included)} files to generate the Table of Contents...")
+    pdf_sim = ModernAnnexPDF(io.BytesIO(), root, mono_font, emoji_font, config)
+    pdf_sim.is_simulation = True
+    pdf_sim.build(included)
+
+    print("🚀 Step 2/2: Generating the final document with images and code...")
+    pdf_final = ModernAnnexPDF(output, root, mono_font, emoji_font, config)
+    pdf_final.summary_data = pdf_sim.summary_data
+    pdf_final.build(included)
+
+    print(f"✅ Success! The annex was saved to: {output}")
+
+
+if __name__ == "__main__":
+    main()

codeannex/config.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.units import mm, cm
+
+# ── Page (default) ───────────────────────────────
+PAGE_W, PAGE_H = A4
+_DEFAULT_MARGIN_LEFT    = 1.5 * cm
+_DEFAULT_MARGIN_RIGHT   = 1.5 * cm
+_DEFAULT_MARGIN_TOP     = 2.0 * cm
+_DEFAULT_MARGIN_BOTTOM  = 2.0 * cm
+
+# ── Code ───────────────────────────────────────
+CODE_FONT_SIZE = 10
+CODE_LINE_H    = CODE_FONT_SIZE * 1.4
+GUTTER_W       = 14 * mm
+
+# ── Colors ────────────────────────────────────────
+COLOR_PAGE_BG   = colors.HexColor("#ffffff")
+COLOR_TEXT_MAIN = colors.HexColor("#4c4f69")
+COLOR_CODE_BG   = colors.HexColor("#1e1e2e")
+COLOR_GUTTER_BG = colors.HexColor("#181825")
+COLOR_GUTTER_FG = colors.HexColor("#bac2de")
+COLOR_HEADER_BG = colors.HexColor("#313244")
+COLOR_HEADER_FG = colors.HexColor("#cdd6f4")
+COLOR_ACCENT    = colors.HexColor("#89b4fa")
+
+# ── Base fonts ──────────────────────────────────
+NORMAL_FONT = "Helvetica"
+BOLD_FONT   = "Helvetica-Bold"
+
+# ── Supported image extensions ───────────────
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".ico", ".gif", ".webp", ".bmp", ".svg"}
+
+# ── Binary extensions to ignore quickly ──────
+BINARY_EXTENSIONS = {".pdf", ".pyc", ".pyo", ".exe", ".dll", ".so", ".dylib",
+                     ".zip", ".tar", ".gz", ".rar", ".7z", ".jar", ".whl",
+                     ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx"}
+
+
+@dataclass
+class PDFConfig:
+    """PDF configuration for code annex."""
+    project_name: str | None = None
+    margin_left: float = _DEFAULT_MARGIN_LEFT
+    margin_right: float = _DEFAULT_MARGIN_RIGHT
+    margin_top: float = _DEFAULT_MARGIN_TOP
+    margin_bottom: float = _DEFAULT_MARGIN_BOTTOM
+    start_page_num: int = 1
+    show_project_name: bool = False
+    normal_font: str = NORMAL_FONT
+    bold_font: str = BOLD_FONT
+    mono_font: str | None = None  # Will be set by register_best_font
+    emoji_font: str | None = None  # Will be set by register_emoji_font
+    emoji_description: bool = False  # Print descriptions instead of emojis
+    repo_url: str | None = None  # URL of the repository for the cover page
+    page_number_size: int = 8  # Font size for page numbers
+
+    def get_code_x(self) -> float:
+        """Calculates the initial X position of the code."""
+        return self.margin_left + GUTTER_W
+
+    def get_code_w(self) -> float:
+        """Calculates the available width for code."""
+        return PAGE_W - self.get_code_x() - self.margin_right

codeannex/file_utils.py

@@ -0,0 +1,116 @@
+import fnmatch
+import os
+import subprocess
+from pathlib import Path
+
+
+def classify_file(filepath: Path) -> str:
+    """
+    Detects binaries cross-platform (Windows/Linux/macOS).
+    Simple and reliable heuristic: null bytes = binary
+    Returns: "text", "binary", or "error"
+    """
+    try:
+        # Empty files are text
+        if filepath.stat().st_size == 0:
+            return "text"
+
+        # Read first 512 bytes (enough to detect null bytes)
+        with open(filepath, "rb") as f:
+            chunk = f.read(512)
+
+        # Null bytes is the most reliable indicator of binary
+        # (works on Windows, Linux, macOS without dependencies)
+        if b"\0" in chunk:
+            return "binary"
+
+        return "text"
+    except Exception:
+        return "error"
+
+
+def is_text_file(filepath: Path) -> bool:
+    # Rejeita extensões binárias conhecidas rapidamente
+    binary_extensions = {".pdf", ".pyc", ".pyo", ".exe", ".dll", ".so", ".dylib",
+                        ".zip", ".tar", ".gz", ".rar", ".7z", ".jar", ".whl"}
+    if filepath.suffix.lower() in binary_extensions:
+        return False
+
+    return classify_file(filepath) == "text"
+
+
+def is_binary_file(filepath: Path) -> bool:
+    return classify_file(filepath) == "binary"
+
+
+class FallbackGitignoreFilter:
+    def __init__(self, root: Path):
+        self.root = root
+        gi = root / ".gitignore"
+        self.rules = []
+        if gi.exists():
+            for line in gi.read_text(encoding="utf-8", errors="replace").splitlines():
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    self.rules.append(line.rstrip("/"))
+
+    def is_ignored(self, path: Path) -> bool:
+        try:
+            rel = path.relative_to(self.root)
+        except ValueError:
+            return False
+        rel_str = rel.as_posix()
+        parts   = rel.parts
+        for rule in self.rules:
+            if rule.startswith("/"):
+                r = rule[1:]
+                if fnmatch.fnmatch(rel_str, r) or fnmatch.fnmatch(rel_str, f"{r}/*"):
+                    return True
+            else:
+                if fnmatch.fnmatch(rel_str, rule) or fnmatch.fnmatch(rel_str, f"{rule}/*"):
+                    return True
+                if any(fnmatch.fnmatch(p, rule) for p in parts):
+                    return True
+        return False
+
+
+def sort_files(files: list[Path], root: Path) -> list[Path]:
+    """
+    Sorts files respecting the rule:
+    - Root files first, in alphabetical order
+    - Then each directory (alphabetical), recursively with the same rule
+    """
+    def sort_key(p: Path):
+        parts = p.relative_to(root).parts
+        # Intercala cada parte com um flag (1 = está dentro de dir, 0 = é arquivo na raiz do nível)
+        # Para cada nível exceto o último (nome do arquivo), coloca (1, nome_dir)
+        # Para o arquivo em si, coloca (0, nome) no seu nível
+        dirs  = parts[:-1]
+        fname = parts[-1]
+        return tuple(val for d in dirs for val in (1, d.lower())) + (0, fname.lower())
+
+    return sorted(files, key=sort_key)
+
+
+def get_project_files(root: Path) -> list[Path]:
+    try:
+        subprocess.run(["git", "rev-parse", "--is-inside-work-tree"],
+                       cwd=root, capture_output=True, check=True)
+        tracked   = subprocess.run(["git", "ls-files", "-z"],
+                                   cwd=root, capture_output=True, check=True).stdout.split(b"\0")
+        untracked = subprocess.run(["git", "ls-files", "-z", "--others", "--exclude-standard"],
+                                   cwd=root, capture_output=True, check=True).stdout.split(b"\0")
+        files = [root / f.decode() for f in set(tracked + untracked) if f]
+        print("✅ Using Git's native engine to perfectly interpret .gitignore.")
+        return sorted(files)
+
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print("⚠️ Git not detected in the project. Using manual scan with Fallback.")
+        system_ignores = {".git", "node_modules", "__pycache__", "venv", ".venv", "dist", "build"}
+        filt  = FallbackGitignoreFilter(root)
+        files = []
+        for dp, dns, fns in os.walk(root):
+            curr   = Path(dp)
+            dns[:] = [d for d in dns if d not in system_ignores and not filt.is_ignored(curr / d)]
+            files.extend(curr / f for f in fns if not filt.is_ignored(curr / f))
+        return sorted(files)

codeannex/fonts.py

@@ -0,0 +1,271 @@
+import io
+import logging
+
+from PIL import Image as PilImage, ImageDraw as PilImageDraw, ImageFont as PilImageFont
+from reportlab.lib.utils import ImageReader
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+
+from .config import CODE_FONT_SIZE, COLOR_GUTTER_FG
+
+logging.getLogger("svglib").setLevel(logging.ERROR)
+
+# ── Caminhos de busca ────────────────────────────
+TTF_SEARCH_PATHS = [
+    "C:\\Windows\\Fonts\\consola.ttf", "C:\\Windows\\Fonts\\cour.ttf",
+    "C:\\Windows\\Fonts\\lucon.ttf",
+    "/System/Library/Fonts/Supplemental/Courier New.ttf",
+    "/System/Library/Fonts/Menlo.ttc", "/System/Library/Fonts/Monaco.ttf",
+    "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",
+    "/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf",
+    "/usr/share/fonts/truetype/ubuntu/UbuntuMono-R.ttf",
+]
+EMOJI_SEARCH_PATHS = [
+    # Monochromatic fonts work best with ReportLab
+    "/usr/share/fonts/truetype/ancient-scripts/Symbola_hint.ttf",  # High coverage, monochromatic
+    "/usr/share/fonts/truetype/noto/NotoEmoji-Regular.ttf",         # Standard monochromatic Noto Emoji
+    # Cross-platform fonts with reasonable coverage
+    "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",              # Better for general Unicode
+    "/usr/share/fonts/truetype/ubuntu/Ubuntu-R.ttf",
+    # Google/Noto color fonts (fallback, may not work in all reportlab versions)
+    "/usr/share/fonts/truetype/noto/NotoSans-Regular.ttf",
+    "/usr/share/fonts/truetype/noto/NotoColorEmoji.ttf",
+    # Platform-specific fonts
+    "/Library/Fonts/Arial Unicode.ttf",
+    "/System/Library/Fonts/Supplemental/Apple Symbols.ttf",
+    "/System/Library/Fonts/Apple Color Emoji.ttc",
+    "C:\\Windows\\Fonts\\seguisym.ttf", "C:\\Windows\\Fonts\\seguiemj.ttf",
+]
+
+
+def _register_font(name: str, paths: list, fallback):
+    import os
+    for p in paths:
+        if os.path.exists(p):
+            try:
+                pdfmetrics.registerFont(TTFont(name, p))
+                return name, p
+            except Exception:
+                continue
+    return fallback, None
+
+
+def register_best_font():
+    name, path = _register_font("CustomMono", TTF_SEARCH_PATHS, "Courier")
+    return name, name != "Courier", path
+
+
+def register_emoji_font(error_on_missing=False):
+    name, path = _register_font("CustomEmoji", EMOJI_SEARCH_PATHS, None)
+    if name is None:
+        # Fallback: try to use DejaVu fonts for unicode support
+        try:
+            dejavu_paths = [
+                "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+                "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",
+            ]
+            name, path = _register_font("CustomEmoji", dejavu_paths, None)
+        except Exception:
+            pass
+    
+    if name is None:
+        msg = (
+            "❌ Error: No emoji font found on your system.\n"
+            "   Emojis cannot be rendered correctly without a dedicated font.\n\n"
+            "   Solutions:\n"
+            "   1. Install a font like 'Google Noto Emoji' or 'DejaVu Sans'.\n"
+            "      - Ubuntu/Debian: sudo apt install fonts-noto-color-emoji\n"
+            "      - Fedora: sudo dnf install google-noto-emoji-color-fonts\n"
+            "      - Arch: sudo pacman -S noto-fonts-emoji\n"
+            "   2. Use the --emoji-description flag to print [emoji descriptions] instead.\n"
+            "   3. Manually specify a font path using --emoji-font \"/path/to/font.ttf\""
+        )
+        if error_on_missing:
+            import sys
+            print(msg, file=sys.stderr)
+            sys.exit(1)
+        else:
+            print("⚠️  Warning: Dedicated Emoji font not found. Emojis may not render correctly.")
+    else:
+        emoji_style = get_emoji_font_style(path)
+        if emoji_style:
+            print(f"ℹ️  Using {emoji_style} emoji style (font: {path})")
+    return name
+
+
+def get_emoji_font_style(font_path: str | None) -> str | None:
+    """Detects the emoji style based on the font path."""
+    if not font_path:
+        return None
+
+    font_path_lower = font_path.lower()
+
+    # Google/Noto fonts
+    if "noto" in font_path_lower:
+        if "color" in font_path_lower:
+            return "Google Noto Color"
+        elif "emoji" in font_path_lower:
+            return "Google Noto Emoji"
+        else:
+            return "Google Noto"
+
+    # Apple fonts
+    if "apple" in font_path_lower:
+        return "Apple"
+
+    # Microsoft fonts
+    if "segui" in font_path_lower or "windows" in font_path_lower:
+        return "Microsoft/Windows"
+
+    # Other common fonts
+    if "symbola" in font_path_lower:
+        return "Symbola (Unicode)"
+    if "dejavu" in font_path_lower:
+        return "DejaVu"
+    if "ubuntu" in font_path_lower:
+        return "Ubuntu"
+
+    return "Unknown"
+
+
+def is_google_like_emoji_font(font_path: str | None) -> bool:
+    """Checks if the emoji font is Google-like (Noto-based)."""
+    if not font_path:
+        return False
+    return "noto" in font_path.lower()
+
+
+def get_current_emoji_font_info() -> dict:
+    """Returns information about the currently registered emoji font."""
+    from reportlab.pdfbase import pdfmetrics
+
+    if "CustomEmoji" in pdfmetrics._fonts:
+        # Tentar obter o caminho da fonte (se disponível)
+        font_obj = pdfmetrics._fonts["CustomEmoji"]
+        # Esta é uma simplificação - na prática pode ser mais complexo
+        # obter o caminho original da fonte registrada
+        return {
+            "name": "CustomEmoji",
+            "is_registered": True,
+            "is_google_like": False,  # Não podemos determinar sem o caminho
+            "style": "Unknown"
+        }
+
+    return {
+        "name": None,
+        "is_registered": False,
+        "is_google_like": False,
+        "style": None
+    }
+
+
+# ── Character support cache ───────────────
+_FONT_CACHE: dict = {}
+
+
+_EMOJI_CACHE: dict[str, bool] = {}
+_EMOJI_RANGES = [
+    (0x1F300, 0x1F9FF),  # Símbolos diversos, pictogramas, emoticons, transporte, etc
+    (0x2600, 0x26FF),    # Símbolos diversos
+    (0x2700, 0x27BF),    # Dingbats
+    (0x1F900, 0x1F9FF),  # Supplemental Symbols and Pictographs
+    (0x1F680, 0x1F6FF),  # Transport and Map Symbols
+    (0x2300, 0x23FF),    # Miscellaneous Technical
+    (0x2B50, 0x2B55),    # Stars
+    (0x1F004, 0x1F0FF),  # Emoticons
+]
+
+
+def is_emoji(char: str) -> bool:
+    """Detects if a character is an emoji based on known Unicode ranges (with cache)."""
+    if char in _EMOJI_CACHE:
+        return _EMOJI_CACHE[char]
+
+    # Check if any code point in the string is in emoji ranges
+    result = any(
+        any(start <= ord(c) <= end for start, end in _EMOJI_RANGES)
+        for c in char
+    )
+    _EMOJI_CACHE[char] = result
+    return result
+
+
+def is_char_supported(char: str, font_name: str) -> bool:
+    """Checks if the font has a glyph for the character. Emojis are always considered supported if emoji_font exists."""
+    if font_name not in _FONT_CACHE:
+        try:
+            _FONT_CACHE[font_name] = pdfmetrics.getFont(font_name)
+        except Exception:
+            return False
+
+    try:
+        f = _FONT_CACHE[font_name]
+        char_code = ord(char)
+
+        # Check the font's glyph map
+        if hasattr(f, "face") and hasattr(f.face, "charToGlyph"):
+            return char_code in f.face.charToGlyph
+
+        # Fallback: supports ASCII
+        return char_code <= 255
+    except Exception:
+        return False
+
+
+# ── Digit sprites (non-selectable) ─────────
+DIGIT_SPRITES: dict | None = None
+
+
+def get_digit_sprites() -> dict:
+    if DIGIT_SPRITES is None:
+        raise RuntimeError("init_sprites() was not called before get_digit_sprites().")
+    return DIGIT_SPRITES
+
+
+def init_sprites(is_ttf: bool, ttf_path: str | None):
+    global DIGIT_SPRITES
+    if DIGIT_SPRITES is not None:
+        return
+    DIGIT_SPRITES = {}
+    color_hex = "#bac2de"
+
+    try:
+        import cairosvg
+        cairo_available = True
+    except ImportError:
+        cairo_available = False
+
+    for d in "0123456789":
+        if cairo_available:
+            svg_str = (
+                f'<svg xmlns="http://www.w3.org/2000/svg" width="50" height="50">'
+                f'<text x="25" y="40" font-family="monospace" font-size="40" '
+                f'fill="{color_hex}" text-anchor="middle">{d}</text></svg>'
+            )
+            png_data = cairosvg.svg2png(bytestring=svg_str.encode(), scale=4.0)
+            img = PilImage.open(io.BytesIO(png_data))
+        else:
+            box_size = 200
+            font = None
+            if is_ttf and ttf_path:
+                try:
+                    font = PilImageFont.truetype(ttf_path, box_size)
+                except Exception:
+                    pass
+            font = font or PilImageFont.load_default()
+            r = int(COLOR_GUTTER_FG.red * 255)
+            g = int(COLOR_GUTTER_FG.green * 255)
+            b = int(COLOR_GUTTER_FG.blue * 255)
+            img_large = PilImage.new("RGBA", (box_size, box_size), (0, 0, 0, 0))
+            draw = PilImageDraw.Draw(img_large)
+            try:
+                draw.text((box_size // 2, int(box_size * 0.8)), d, font=font,
+                          fill=(r, g, b, 255), anchor="ms")
+            except TypeError:
+                draw.text((box_size // 4, box_size // 4), d, font=font, fill=(r, g, b, 255))
+            img = img_large.resize((50, 50), PilImage.Resampling.LANCZOS)
+
+        buf = io.BytesIO()
+        img.save(buf, format="PNG")
+        buf.seek(0)
+        DIGIT_SPRITES[d] = ImageReader(buf)

codeannex/highlight.py

@@ -0,0 +1,21 @@
+from pygments.token import Token
+
+TOKEN_COLORS = {
+    Token:                   "#cdd6f4",
+    Token.Keyword:           "#cba6f7",
+    Token.Keyword.Namespace: "#89dceb",
+    Token.Name.Function:     "#89b4fa",
+    Token.Name.Class:        "#f9e2af",
+    Token.Literal.String:    "#a6e3a1",
+    Token.Literal.Number:    "#fab387",
+    Token.Comment:           "#6c7086",
+    Token.Operator:          "#89dceb",
+}
+
+
+def get_token_color(ttype) -> str:
+    while ttype is not None:
+        if ttype in TOKEN_COLORS:
+            return TOKEN_COLORS[ttype]
+        ttype = ttype.parent
+    return "#cdd6f4"