anchorsfactory 0.2.0__py3-none-any.whl

anchorsfactory/__init__.py

@@ -0,0 +1,36 @@
+"""AnchorsFactory — rule-driven anchor placement for UFO fonts."""
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+try:
+    __version__ = _pkg_version("anchorsfactory")
+except PackageNotFoundError:  # running from a source tree without an install
+    __version__ = "0.0.0+unknown"
+
+from .apply import apply_document, accumulate, validate_document
+from .parser import parse_document, parse_file, ParseError
+from .dsl import parse_dsl, parse_dsl_file, DSLError
+from .convert import convert_file, render_document, verify_conversion
+from .presets import list_presets, preset_text, is_preset
+from .runner import process_ufo, load_document
+
+__all__ = [
+    "__version__",
+    "apply_document",
+    "accumulate",
+    "validate_document",
+    "parse_document",
+    "parse_file",
+    "ParseError",
+    "parse_dsl",
+    "parse_dsl_file",
+    "DSLError",
+    "convert_file",
+    "render_document",
+    "verify_conversion",
+    "list_presets",
+    "preset_text",
+    "is_preset",
+    "process_ufo",
+    "load_document",
+]

anchorsfactory/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

anchorsfactory/apply.py

@@ -0,0 +1,137 @@
+"""Apply a parsed :class:`Document` to a font: place the anchors.
+
+Resolution follows the accumulation model: rules are scanned in file order and
+every rule whose selector matches a glyph mutates that glyph's anchor list —
+``=`` replaces it, ``+=`` appends. This single path serves both front-ends
+(the legacy parser emits all-``REPLACE`` rules, so each glyph matched once
+behaves exactly as before).
+
+Coordinate maths is delegated to :mod:`anchorsfactory.geometry`.
+"""
+
+from __future__ import annotations
+
+import fnmatch
+import logging
+import unicodedata
+
+from .geometry import resolve
+from .model import (
+    Document, Op, LabelRef,
+    GlyphName, Unicode, UnicodeRange, Glob, Category,
+)
+
+log = logging.getLogger(__name__)
+
+
+def _resolve_items(items, labels, _seen=()):
+    """Expand LabelRefs to concrete AnchorSpecs against *labels* (late binding)."""
+    specs = []
+    for it in items:
+        if isinstance(it, LabelRef):
+            if it.name in _seen:
+                raise ValueError(f"label cycle through {it.name}")
+            if it.name not in labels:
+                raise ValueError(f"undefined label {it.name}")
+            specs.extend(_resolve_items(labels[it.name], labels, _seen + (it.name,)))
+        else:
+            specs.append(it)
+    return specs
+
+
+def _remove_targets(items, labels):
+    """Names to drop for a REMOVE rule: bare names plus the names a label defines."""
+    names = set()
+    for it in items:
+        if isinstance(it, LabelRef):
+            names.update(s.name for s in _resolve_items([it], labels))
+        else:
+            names.add(it)
+    return names
+
+
+def _matches(selector, name: str, unicodes) -> bool:
+    if isinstance(selector, GlyphName):
+        return name == selector.name
+    if isinstance(selector, Unicode):
+        return selector.codepoint in unicodes
+    if isinstance(selector, UnicodeRange):
+        return any(selector.start <= u <= selector.end for u in unicodes)
+    if isinstance(selector, Glob):
+        return fnmatch.fnmatchcase(name, selector.pattern)
+    if isinstance(selector, Category):
+        return any(unicodedata.category(chr(u)).startswith(selector.value) for u in unicodes)
+    raise TypeError(f"unknown selector {selector!r}")
+
+
+def validate_document(doc: Document) -> list[str]:
+    """Pre-flight check (font-independent): every @label reference resolves.
+
+    Returns a list of human-readable problems (empty = ok). Catches typo'd
+    label names up front instead of at apply time, glyph by glyph.
+    """
+    problems = []
+    for lname, items in doc.labels.items():
+        for it in items:
+            if isinstance(it, LabelRef) and it.name not in doc.labels:
+                problems.append(f"label {lname}: undefined label {it.name}")
+    for sel, op, items in doc.rules:
+        for it in items:
+            if isinstance(it, LabelRef) and it.name not in doc.labels:
+                problems.append(f"rule {sel}: undefined label {it.name}")
+    return problems
+
+
+def accumulate(doc: Document, name: str, unicodes) -> list:
+    """Build a glyph's anchor list by applying matching rules in order.
+
+    ``=`` replaces, ``+=`` appends, ``-=`` drops by anchor name. Labels are
+    resolved here, against ``doc.labels``, so overrides take effect late.
+    """
+    acc: list = []
+    for selector, op, items in doc.rules:
+        if not _matches(selector, name, unicodes):
+            continue
+        if op is Op.REMOVE:
+            drop = _remove_targets(items, doc.labels)
+            acc = [s for s in acc if s.name not in drop]
+        else:
+            specs = _resolve_items(items, doc.labels)
+            acc = specs if op is Op.REPLACE else acc + specs
+    return acc
+
+
+def apply_document(font, doc: Document, *, clear=True, replace=True, round_coords=True):
+    """Place all anchors described by *doc* onto *font* (in place).
+
+    ``round_coords`` rounds placed anchors to whole units (the usual choice for
+    a UFO); the golden regression passes ``False`` to compare raw precision.
+    """
+    for glyph in font:
+        specs = accumulate(doc, glyph.name, list(glyph.unicodes))
+        if not specs:
+            continue
+        for sfx in doc.suffixes:
+            gname = glyph.name + sfx
+            if gname in font:
+                _place(font, font[gname], specs, doc.shift_x, clear, replace, round_coords)
+
+
+def _remove_named(glyph, name):
+    for anchor in list(glyph.anchors):
+        if anchor.name == name:
+            glyph.removeAnchor(anchor)
+
+
+def _place(font, glyph, specs, shift_x, clear, replace, round_coords):
+    if clear:
+        for anchor in list(glyph.anchors):
+            glyph.removeAnchor(anchor)
+    for spec in specs:
+        x, y = resolve(font, glyph, spec)
+        if replace:
+            _remove_named(glyph, spec.name)
+        x += shift_x
+        if round_coords:
+            x, y = round(x), round(y)
+        glyph.appendAnchor(spec.name, (x, y))

anchorsfactory/cli.py

@@ -0,0 +1,124 @@
+"""Command-line interface for AnchorsFactory.
+
+Replaces the legacy module-level script and batch.py. Accepts one or more
+UFO paths (a directory expands to its ``*.ufo`` files), applies a rule file,
+and saves — safely by default (never overwriting the source unless asked).
+
+Logging is configured here, at the application entry point — never via
+``logging.basicConfig`` inside the library — so batch runs get a clean,
+per-font log file instead of everything landing in the first font's log.
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import logging
+import os
+import sys
+from datetime import datetime
+
+from .apply import validate_document
+from .runner import load_document, process_ufo
+
+log = logging.getLogger("anchorsfactory")
+
+
+def _expand_inputs(paths: list[str]) -> list[str]:
+    ufos: list[str] = []
+    for p in paths:
+        if os.path.isdir(p) and not p.lower().endswith(".ufo"):
+            ufos.extend(sorted(glob.glob(os.path.join(p, "*.ufo"))))
+        else:
+            ufos.append(p)
+    return ufos
+
+
+def _setup_console_logging(verbose: bool) -> None:
+    log.setLevel(logging.DEBUG if verbose else logging.INFO)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
+    log.addHandler(handler)
+
+
+def _font_log_handler(log_dir: str, ufo_path: str) -> logging.Handler:
+    os.makedirs(log_dir, exist_ok=True)
+    stem = os.path.splitext(os.path.basename(ufo_path.rstrip(os.sep)))[0]
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    handler = logging.FileHandler(os.path.join(log_dir, f"{ts}_{stem}.log"), encoding="utf-8")
+    handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+    return handler
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="anchorsfactory",
+        description="Place anchors in UFO fonts from a rule file.",
+    )
+    p.add_argument("ufo", nargs="+", help="UFO file(s) or a directory of UFOs")
+    p.add_argument("-r", "--rules", required=True, help="path to the anchor rules file")
+    out = p.add_mutually_exclusive_group()
+    out.add_argument("-o", "--output", help="output UFO path (single input only)")
+    out.add_argument("--in-place", action="store_true", help="overwrite the source UFO")
+    p.add_argument("--backup-dir", help="dump existing anchors here before applying")
+    p.add_argument("--keep-existing", action="store_true",
+                   help="do not clear existing anchors before applying")
+    p.add_argument("--no-round", action="store_true", help="keep fractional anchor coordinates")
+    p.add_argument("--log-dir", help="write a per-font log file into this directory")
+    p.add_argument("-v", "--verbose", action="store_true")
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    _setup_console_logging(args.verbose)
+
+    inputs = _expand_inputs(args.ufo)
+    if not inputs:
+        log.error("no UFO inputs found")
+        return 2
+    if args.output and len(inputs) > 1:
+        log.error("--output cannot be used with multiple inputs; use --in-place or default naming")
+        return 2
+
+    # Load + validate the rules once, up front: fail fast on rule errors before
+    # touching any font.
+    try:
+        document = load_document(args.rules)
+    except Exception as e:  # noqa: BLE001 — surface a clean message, not a traceback
+        log.error("cannot load rules %s: %s", args.rules, e)
+        return 2
+    problems = validate_document(document)
+    if problems:
+        for msg in problems:
+            log.error("rules: %s", msg)
+        return 2
+
+    failures = 0
+    for ufo in inputs:
+        fh = _font_log_handler(args.log_dir, ufo) if args.log_dir else None
+        if fh:
+            log.addHandler(fh)
+        try:
+            process_ufo(
+                ufo, args.rules,
+                output=args.output,
+                in_place=args.in_place,
+                backup_dir=args.backup_dir,
+                clear=not args.keep_existing,
+                round_coords=not args.no_round,
+                document=document,
+            )
+        except Exception as e:  # noqa: BLE001 — report per-font, continue the batch
+            log.error("Failed on %s: %s", ufo, e)
+            failures += 1
+        finally:
+            if fh:
+                log.removeHandler(fh)
+                fh.close()
+
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

anchorsfactory/convert.py

@@ -0,0 +1,102 @@
+"""Convert a legacy ``.txt`` rule file to the new DSL (docs/anchor-rules.md).
+
+Reuses the IR as the bridge: parse the legacy file to a :class:`Document`
+(via :mod:`anchorsfactory.parser`), then render that Document back out in the
+new surface syntax. Rendering relies on the model's ``__str__``, which already
+emits canonical new-syntax tokens.
+
+Note: rule lines come out with anchors inlined (the legacy parser expands
+label references), so the result is faithful but not re-compressed — you can
+hand-edit it to use labels / ranges afterwards.
+"""
+
+from __future__ import annotations
+
+from .dsl import parse_dsl
+from .parser import parse_file
+
+
+def render_selector(sel) -> str:
+    return str(sel)
+
+
+def render_document(doc) -> str:
+    lines: list[str] = []
+    if doc.shift_x:
+        lines.append(f"!shiftx = {doc.shift_x}")
+    suffixes = [s for s in doc.suffixes if s]
+    if suffixes:
+        lines.append("!suffixes = " + ", ".join(suffixes))
+    if lines:
+        lines.append("")
+
+    if doc.labels:
+        lines.append("# labels")
+        for name, specs in doc.labels.items():
+            lines.append(f"{name} = " + ", ".join(str(s) for s in specs))
+        lines.append("")
+
+    lines.append("# rules")
+    for sel, op, specs in doc.rules:
+        lines.append(f"{render_selector(sel)} {op.value} " + ", ".join(str(s) for s in specs))
+    return "\n".join(lines) + "\n"
+
+
+def convert_file(legacy_path: str) -> str:
+    """Return the new-DSL text for a legacy rule file."""
+    return render_document(parse_file(legacy_path))
+
+
+def verify_conversion(legacy_path: str) -> list[str]:
+    """Round-trip check: legacy -> new text -> IR must equal the legacy IR.
+
+    Returns a list of human-readable mismatches (empty = lossless). Guarantees
+    the conversion preserved every rule, label and directive.
+    """
+    legacy = parse_file(legacy_path)
+    roundtrip = parse_dsl(render_document(legacy).splitlines())
+    problems = []
+    if roundtrip.rules != legacy.rules:
+        problems.append("rules differ after round-trip")
+    if roundtrip.labels != legacy.labels:
+        problems.append("labels differ after round-trip")
+    if roundtrip.shift_x != legacy.shift_x:
+        problems.append("shift_x differs after round-trip")
+    if roundtrip.suffixes != legacy.suffixes:
+        problems.append("suffixes differ after round-trip")
+    return problems
+
+
+def main(argv=None) -> int:
+    import argparse
+    import sys
+
+    p = argparse.ArgumentParser(
+        prog="anchorsfactory-convert",
+        description="Convert a legacy .txt rule file to the new DSL.",
+    )
+    p.add_argument("legacy", help="path to the legacy .txt rule file")
+    p.add_argument("-o", "--output", help="write here instead of stdout")
+    p.add_argument("--no-verify", action="store_true",
+                   help="skip the lossless round-trip check")
+    args = p.parse_args(argv)
+
+    text = convert_file(args.legacy)
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as f:
+            f.write(text)
+    else:
+        sys.stdout.write(text)
+
+    if not args.no_verify:
+        problems = verify_conversion(args.legacy)
+        if problems:
+            for msg in problems:
+                print(f"verify: {msg}", file=sys.stderr)
+            return 1
+        print("verify: round-trip OK — conversion is lossless", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

anchorsfactory/dsl.py

@@ -0,0 +1,240 @@
+"""Parser for the new rule language (docs/anchor-rules.md) -> IR (:class:`Document`).
+
+A second front-end alongside :mod:`anchorsfactory.parser`; both produce the
+same :class:`Document`, so the engine is unchanged. Surface form::
+
+    @label = name (X Y), ...
+    selector =  ...        # replace
+    selector += ...        # accumulate
+    !suffixes = .alt
+    !shiftx   = -15
+"""
+
+from __future__ import annotations
+
+import re
+
+from .model import (
+    Frame, HAlign, VEdge, Run, Frac, FONT_METRICS,
+    X, XAbs, Y, YAbs, FontMetric, YSum, AnchorSpec, LabelRef,
+    GlyphName, Unicode, UnicodeRange, Glob, Category, Op, Document,
+)
+
+
+class DSLError(ValueError):
+    """Raised on a malformed line, with line context."""
+
+
+_FRAME = {"width": Frame.ADVANCE, "box": Frame.BOX, "outline": Frame.OUTLINE}
+_HALIGN = {"left": HAlign.LEFT, "center": HAlign.CENTER, "right": HAlign.RIGHT}
+_RUN = {"first": Run.FIRST, "last": Run.LAST}
+_EDGE = {"top": VEdge.TOP, "middle": VEdge.MIDDLE, "bottom": VEdge.BOTTOM}
+
+_ANCHOR_RE = re.compile(r"^(\S+)\s*\(\s*(\S+)\s+(\S+)\s*\)$")
+_RULE_RE = re.compile(r"^(.*?)\s*(\+=|-=|=)\s*(.*)$")
+_NAME_RE = re.compile(r"^[\w.]+$")
+_OPS = {"=": Op.REPLACE, "+=": Op.ADD, "-=": Op.REMOVE}
+
+
+# --------------------------------------------------------------------------- #
+#  X / Y tokens
+# --------------------------------------------------------------------------- #
+def _parse_x(tok: str):
+    try:
+        return XAbs(int(tok))
+    except ValueError:
+        pass
+    base, _, edge = tok.partition("@")
+    parts = base.split(".")
+    if parts[0] not in _FRAME:
+        raise DSLError(f"unknown X frame in {tok!r}")
+    frame = _FRAME[parts[0]]
+    rest = parts[1:]
+    run = None
+    if len(rest) == 2:
+        run_tok, align_tok = rest
+        if run_tok in _RUN:
+            run = _RUN[run_tok]
+        else:
+            try:
+                run = int(run_tok)
+            except ValueError:
+                raise DSLError(f"bad run {run_tok!r} in {tok!r}")
+    elif len(rest) == 1:
+        align_tok = rest[0]
+    else:
+        raise DSLError(f"malformed X token {tok!r}")
+    if align_tok not in _HALIGN:
+        raise DSLError(f"unknown X align {align_tok!r} in {tok!r}")
+    at = None
+    if edge:
+        # @top/@bottom = the glyph's own extreme; otherwise a fixed sample height
+        at = _EDGE[edge] if edge in _EDGE else _parse_y(edge)
+    return X(frame, _HALIGN[align_tok], run=run, at=at)
+
+
+def _parse_y(tok: str):
+    if "+" in tok:                          # a sum of terms: a+b+c
+        return YSum(tuple(_parse_y_term(t) for t in tok.split("+") if t))
+    return _parse_y_term(tok)
+
+
+def _parse_y_term(tok: str):
+    if not tok.startswith("$"):
+        base, star, frac = tok.partition("*")
+        if base in FONT_METRICS:                 # font metric, optionally *d1/d2
+            if not star:
+                return FontMetric(base)
+            if "/" not in frac:
+                raise DSLError(f"fraction must be d1/d2 in {tok!r}")
+            d1, d2 = frac.split("/", 1)
+            try:
+                return FontMetric(base, Frac(int(d1), int(d2)))
+            except ValueError as e:
+                raise DSLError(f"bad fraction in {tok!r}: {e}")
+        try:
+            return YAbs(int(tok))
+        except ValueError:
+            raise DSLError(f"invalid Y position {tok!r}")
+    body = tok[1:]
+    if "*" in body:
+        glyph, frac = body.split("*", 1)
+        if "/" not in frac:
+            raise DSLError(f"fraction must be d1/d2 in {tok!r}")
+        d1, d2 = frac.split("/", 1)
+        try:
+            return Y(glyph, Frac(int(d1), int(d2)))
+        except ValueError as e:
+            raise DSLError(f"bad fraction in {tok!r}: {e}")
+    if "." in body:
+        glyph, _, suf = body.rpartition(".")
+        if suf in _EDGE:
+            return Y(glyph, _EDGE[suf])
+    return Y(body, VEdge.TOP)
+
+
+def _parse_anchor(tok: str) -> AnchorSpec:
+    m = _ANCHOR_RE.match(tok)
+    if not m:
+        raise DSLError(f"anchor must be 'name (X Y)', got {tok!r}")
+    name, xtok, ytok = m.groups()
+    return AnchorSpec(name, _parse_x(xtok), _parse_y(ytok))
+
+
+# --------------------------------------------------------------------------- #
+#  Selectors
+# --------------------------------------------------------------------------- #
+def _parse_cp(s: str) -> int:
+    return int(s.replace("U+", "").replace("u+", ""), 16)
+
+
+def _parse_selector(tok: str):
+    if tok.startswith(("U+", "u+")):
+        if ".." in tok:
+            a, b = tok.split("..", 1)
+            return UnicodeRange(_parse_cp(a), _parse_cp(b))
+        return Unicode(_parse_cp(tok))
+    if tok.startswith("{") and tok.endswith("}"):
+        return Category(tok[1:-1])
+    if "*" in tok or "?" in tok:
+        return Glob(tok)
+    return GlyphName(tok)
+
+
+# --------------------------------------------------------------------------- #
+#  Lines
+# --------------------------------------------------------------------------- #
+def _split_items(rhs: str) -> list[str]:
+    return [p.strip() for p in rhs.split(",") if p.strip()]
+
+
+def parse_dsl(lines) -> Document:
+    labels: dict[str, list[AnchorSpec]] = {}
+    rules: list = []
+    shift_x = 0
+    suffixes = [""]
+    extends: list[str] = []
+
+    raw_lines = []
+    for n, line in enumerate(lines, 1):
+        line = line.split("#", 1)[0].strip()
+        if not line:
+            continue
+        for stmt in line.split(";"):
+            stmt = stmt.strip()
+            if stmt:
+                raw_lines.append((n, stmt))
+
+    def parse_items(rhs: str, n: int) -> list:
+        # anchors and label refs, unresolved (labels are bound late, at apply)
+        items = []
+        for item in _split_items(rhs):
+            if item.startswith("@"):
+                items.append(LabelRef(item))
+            else:
+                try:
+                    items.append(_parse_anchor(item))
+                except DSLError as e:
+                    raise DSLError(f"line {n}: {e}")
+        return items
+
+    def parse_remove(rhs: str, n: int) -> list:
+        # '-=' takes anchor names (bare) or @labels to strip
+        targets = []
+        for item in _split_items(rhs):
+            if item.startswith("@"):
+                targets.append(LabelRef(item))
+            elif _NAME_RE.match(item):
+                targets.append(item)
+            else:
+                raise DSLError(f"line {n}: '-=' takes anchor names or @labels, got {item!r}")
+        return targets
+
+    for n, stmt in raw_lines:
+        if stmt.startswith("!"):
+            body = stmt[1:].strip()
+            if "=" in body:
+                name, _, value = body.partition("=")
+                name, value = name.strip(), value.strip()
+            else:                                  # e.g. "!extends default"
+                head, _, rest = body.partition(" ")
+                name, value = head.strip(), rest.strip()
+            if name == "suffixes":
+                suffixes.extend((s.strip() if s.strip().startswith(".") else "." + s.strip())
+                                for s in value.split(",") if s.strip())
+            elif name == "shiftx":
+                try:
+                    shift_x = int(value)
+                except ValueError:
+                    raise DSLError(f"line {n}: !shiftx needs an integer, got {value!r}")
+            elif name == "extends":
+                if not value:
+                    raise DSLError(f"line {n}: !extends needs a base name or path")
+                extends.append(value)
+            else:
+                raise DSLError(f"line {n}: unknown directive !{name}")
+            continue
+
+        m = _RULE_RE.match(stmt)
+        if not m:
+            raise DSLError(f"line {n}: missing '=' or '+=' in {stmt!r}")
+        lhs, op_tok, rhs = m.group(1).strip(), m.group(2), m.group(3).strip()
+        if not rhs:
+            raise DSLError(f"line {n}: empty right-hand side")
+
+        if lhs.startswith("@"):
+            if op_tok != "=":
+                raise DSLError(f"line {n}: labels only support '='")
+            labels[lhs] = parse_items(rhs, n)
+        else:
+            op = _OPS[op_tok]
+            items = parse_remove(rhs, n) if op is Op.REMOVE else parse_items(rhs, n)
+            rules.append((_parse_selector(lhs), op, items))
+
+    return Document(labels=labels, rules=rules, shift_x=shift_x,
+                    suffixes=suffixes, extends=extends)
+
+
+def parse_dsl_file(path: str) -> Document:
+    with open(path, encoding="utf-8") as f:
+        return parse_dsl(f.readlines())