"""Read original Type1 dictionaries; acquire native handles without output copies. """ import sys from contextlib import ExitStack, contextmanager def _close(handle): active_error = sys.exc_info()[0] is not None try: handle.close() except Exception: if not active_error: raise @contextmanager def native_font(path=None): """The caller owns this handle through its last copy/reference/generate. """ import fontforge handle = fontforge.font() if path is None else fontforge.open(str(path)) try: yield handle finally: _close(handle) def read_type1(path): from fontTools.t1Lib import T1Font font = T1Font(str(path)) font.parse() if not isinstance(font["Encoding"], list): raise ValueError(str(path) + ": no usable Type1 Encoding") return font def slot_names(font): names = font["CharStrings"] return { slot: name for slot, name in enumerate(font["Encoding"]) if name != ".notdef" and name in names } def slot_path(font, pfb_path, slot): from fontTools.pens.boundsPen import BoundsPen from fontTools.pens.recordingPen import RecordingPen names = slot_names(font) if slot not in names: raise ValueError( f"{pfb_path.name}: Encoding/CharStrings slot {slot} missing" ) name = names[slot] glyphs = font.getGlyphSet() rec = RecordingPen() glyphs[name].draw(rec) bounds = BoundsPen(glyphs) glyphs[name].draw(bounds) return dict( source_file=pfb_path.name, slot=slot, glyph_name=name, bounds=list(bounds.bounds or (0, 0, 0, 0)), path=[ dict(op=op, points=[[float(x), float(y)] for x, y in pts]) for op, pts in rec.value ], ) @contextmanager def source_faces(source_dir, edition, snapshot): """Use catalog metrics; only the native backend opens FontForge PFBs. """ from declarations import active_tags from metrics import from_data faces = {} with ExitStack() as owners: for tag in active_tags(edition): entry = snapshot["catalog"][tag] path = source_dir / (entry["stem"] + ".pfb") try: pfb = owners.enter_context(native_font(path)) slots = { g.encoding: g.glyphname for g in pfb.glyphs() if g.encoding < 0x10000 } tfm = from_data(entry["metrics"]) allowed = snapshot["plan"]["numeric_references"][ "fontdimens" ].get(tag, []) tfm.fontdimen = PlannedDimensions(tfm.fontdimen, tag, allowed) for slot in snapshot["plan"]["native"].get(tag, []): if slot not in slots or slot not in tfm.chars: raise ValueError(f"required native slot {slot} absent") faces[tag] = pfb, tfm, slots except Exception as exc: raise ValueError( f"native source {path.name} role={tag}: {exc}" ) from exc yield faces class PlannedDimensions(dict): """Native numeric reads must match the preflighted source declaration. """ def __init__(self, values, role, allowed): super().__init__(values) self.role, self.allowed, self.used = role, set(allowed), set() def __getitem__(self, index): if index not in self.allowed: raise ValueError( f"unplanned numeric source role={self.role} fontdimen={index}" ) self.used.add(index) return super().__getitem__(index)