pytex-preprocessor 0.1.0__py3-none-any.whl

pytex/commands/colors.py

@@ -0,0 +1,60 @@
+from ..helpers.with_package import with_package
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..packages import XCOLOR
+from ..registry import Registry
+
+__all__ = [
+    "Colorbox",
+    "Definecolor",
+    "Fcolorbox",
+    "Pagecolor",
+    "SelectColor",
+    "Textcolor",
+]
+
+
+@Registry.add
+@with_package(XCOLOR)
+def Definecolor(name: str, model: str, spec: str) -> TeX:
+    return ControlSequence(
+        "definecolor",
+        (Parameter(name), Parameter(model), Parameter(spec)),
+    )
+
+
+@Registry.add
+@with_package(XCOLOR)
+def Textcolor(color: str, body: TeX | str) -> TeX:
+    return ControlSequence("textcolor", (Parameter(color), Parameter(body)))
+
+
+@Registry.add
+@with_package(XCOLOR)
+def SelectColor(color: str) -> TeX:
+    """`\\color{name}` — switch current colour.
+
+    Use `Color` (model) for typed colour identity.
+    """
+    return ControlSequence("color", (Parameter(color),))
+
+
+@Registry.add
+@with_package(XCOLOR)
+def Colorbox(color: str, body: TeX | str) -> TeX:
+    return ControlSequence("colorbox", (Parameter(color), Parameter(body)))
+
+
+@Registry.add
+@with_package(XCOLOR)
+def Fcolorbox(border: str, fill: str, body: TeX | str) -> TeX:
+    return ControlSequence(
+        "fcolorbox",
+        (Parameter(border), Parameter(fill), Parameter(body)),
+    )
+
+
+@Registry.add
+@with_package(XCOLOR)
+def Pagecolor(color: str) -> TeX:
+    return ControlSequence("pagecolor", (Parameter(color),))

pytex/commands/conditionals.py

@@ -0,0 +1,62 @@
+from ..helpers.with_package import with_package
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..packages import ETOOLBOX, IFTHEN
+from ..registry import Registry
+
+__all__ = ["Apptocmd", "Equal", "Ifdefstring", "Ifstrequal", "Ifthenelse", "Pretocmd"]
+
+
+@Registry.add
+@with_package(IFTHEN)
+def Ifthenelse(condition: TeX | str, then: TeX | str, otherwise: TeX | str) -> TeX:
+    return ControlSequence(
+        "ifthenelse",
+        (Parameter(condition), Parameter(then), Parameter(otherwise)),
+    )
+
+
+@Registry.add
+@with_package(IFTHEN)
+def Equal(a: TeX | str, b: TeX | str) -> TeX:
+    return ControlSequence("equal", (Parameter(a), Parameter(b)))
+
+
+@Registry.add
+@with_package(ETOOLBOX)
+def Ifstrequal(
+    a: TeX | str, b: TeX | str, then: TeX | str, otherwise: TeX | str
+) -> TeX:
+    return ControlSequence(
+        "ifstrequal",
+        (Parameter(a), Parameter(b), Parameter(then), Parameter(otherwise)),
+    )
+
+
+@Registry.add
+@with_package(ETOOLBOX)
+def Ifdefstring(
+    cmd: str, target: TeX | str, then: TeX | str, otherwise: TeX | str
+) -> TeX:
+    return ControlSequence(
+        "ifdefstring",
+        (Parameter(cmd), Parameter(target), Parameter(then), Parameter(otherwise)),
+    )
+
+
+@Registry.add
+@with_package(ETOOLBOX)
+def Pretocmd(cmd: str, prepend: TeX | str) -> TeX:
+    return ControlSequence(
+        "pretocmd",
+        (Parameter(cmd), Parameter(prepend), Parameter(""), Parameter("")),
+    )
+
+
+@Registry.add
+@with_package(ETOOLBOX)
+def Apptocmd(cmd: str, append: TeX | str) -> TeX:
+    return ControlSequence(
+        "apptocmd",
+        (Parameter(cmd), Parameter(append), Parameter(""), Parameter("")),
+    )

pytex/commands/counters.py

@@ -0,0 +1,85 @@
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..model.raw import Raw
+from ..registry import Registry
+
+__all__ = [
+    "Addtocounter",
+    "Alph",
+    "AlphUpper",
+    "Arabic",
+    "Newcounter",
+    "Refstepcounter",
+    "RomanCounter",
+    "RomanCounterUpper",
+    "Setcounter",
+    "Stepcounter",
+    "UseCounter",
+    "Value",
+]
+
+
+@Registry.add
+def Newcounter(name: str, within: str | None = None) -> TeX:
+    if within is None:
+        return ControlSequence("newcounter", (Parameter(name),))
+    return ControlSequence(
+        "newcounter",
+        (Parameter(name), Parameter(within, optional=True)),
+    )
+
+
+@Registry.add
+def Setcounter(name: str, value: int | str) -> TeX:
+    return ControlSequence("setcounter", (Parameter(name), Parameter(str(value))))
+
+
+@Registry.add
+def Addtocounter(name: str, value: int | str) -> TeX:
+    return ControlSequence("addtocounter", (Parameter(name), Parameter(str(value))))
+
+
+@Registry.add
+def Stepcounter(name: str) -> TeX:
+    return ControlSequence("stepcounter", (Parameter(name),))
+
+
+@Registry.add
+def Refstepcounter(name: str) -> TeX:
+    return ControlSequence("refstepcounter", (Parameter(name),))
+
+
+@Registry.add
+def Value(name: str) -> TeX:
+    return ControlSequence("value", (Parameter(name),))
+
+
+@Registry.add
+def Arabic(name: str) -> TeX:
+    return ControlSequence("arabic", (Parameter(name),))
+
+
+@Registry.add
+def RomanCounter(name: str) -> TeX:
+    return ControlSequence("roman", (Parameter(name),))
+
+
+@Registry.add
+def RomanCounterUpper(name: str) -> TeX:
+    return ControlSequence("Roman", (Parameter(name),))
+
+
+@Registry.add
+def Alph(name: str) -> TeX:
+    return ControlSequence("alph", (Parameter(name),))
+
+
+@Registry.add
+def AlphUpper(name: str) -> TeX:
+    return ControlSequence("Alph", (Parameter(name),))
+
+
+@Registry.add
+def UseCounter(name: str) -> TeX:
+    """Render `\\thecounter` for given counter name."""
+    return Raw(f"\\the{name}")

pytex/commands/definitions.py

@@ -0,0 +1,109 @@
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..model.raw import Raw
+from ..registry import Registry
+
+__all__ = [
+    "DeclareRobustCommand",
+    "Def",
+    "Newcommand",
+    "Newenvironment",
+    "Providecommand",
+    "Renewcommand",
+    "Renewenvironment",
+]
+
+
+def _cmd(
+    name: str,
+    cs: str,
+    nargs: int | None,
+    default: str | None,
+    body: TeX | str,
+    star: bool,
+) -> TeX:
+    full = name + ("*" if star else "")
+    params: list[Parameter] = [Parameter(Raw(cs))]
+    if nargs is not None:
+        params.append(Parameter(str(nargs), optional=True))
+        if default is not None:
+            params.append(Parameter(default, optional=True))
+    params.append(Parameter(body))
+    return ControlSequence(full, tuple(params))
+
+
+@Registry.add
+def Newcommand(
+    cs: str,
+    body: TeX | str,
+    nargs: int | None = None,
+    default: str | None = None,
+    star: bool = False,
+) -> TeX:
+    return _cmd("newcommand", cs, nargs, default, body, star)
+
+
+@Registry.add
+def Renewcommand(
+    cs: str,
+    body: TeX | str,
+    nargs: int | None = None,
+    default: str | None = None,
+    star: bool = False,
+) -> TeX:
+    return _cmd("renewcommand", cs, nargs, default, body, star)
+
+
+@Registry.add
+def Providecommand(
+    cs: str,
+    body: TeX | str,
+    nargs: int | None = None,
+    default: str | None = None,
+    star: bool = False,
+) -> TeX:
+    return _cmd("providecommand", cs, nargs, default, body, star)
+
+
+@Registry.add
+def DeclareRobustCommand(
+    cs: str,
+    body: TeX | str,
+    nargs: int | None = None,
+    star: bool = False,
+) -> TeX:
+    return _cmd("DeclareRobustCommand", cs, nargs, None, body, star)
+
+
+@Registry.add
+def Newenvironment(
+    name: str,
+    begin: TeX | str,
+    end: TeX | str,
+    nargs: int | None = None,
+) -> TeX:
+    params: list[Parameter] = [Parameter(name)]
+    if nargs is not None:
+        params.append(Parameter(str(nargs), optional=True))
+    params.extend([Parameter(begin), Parameter(end)])
+    return ControlSequence("newenvironment", tuple(params))
+
+
+@Registry.add
+def Renewenvironment(
+    name: str,
+    begin: TeX | str,
+    end: TeX | str,
+    nargs: int | None = None,
+) -> TeX:
+    params: list[Parameter] = [Parameter(name)]
+    if nargs is not None:
+        params.append(Parameter(str(nargs), optional=True))
+    params.extend([Parameter(begin), Parameter(end)])
+    return ControlSequence("renewenvironment", tuple(params))
+
+
+@Registry.add
+def Def(cs: str, body: TeX | str) -> TeX:
+    """Low-level TeX \\def — use sparingly."""
+    return Raw(f"\\def\\{cs}{{{body}}}")

pytex/commands/floats.py

@@ -0,0 +1,93 @@
+from ..helpers.with_package import with_package
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..model.environment import Environment
+from ..packages import FLOAT, FLOATROW
+from ..registry import Registry
+
+__all__ = [
+    "Columnbreak",
+    "Figure",
+    "FigureStar",
+    "Floatsetup",
+    "Minipage",
+    "Multicols",
+    "Newfloat",
+    "Restylefloat",
+    "Table",
+    "TableStar",
+    "Titlepage",
+]
+
+
+def _placed(name: str, body: TeX | str, placement: str | None) -> TeX:
+    if placement is None:
+        return Environment(name, body)
+    return Environment(name, body, (Parameter(placement, optional=True),))
+
+
+@Registry.add
+def Figure(body: TeX | str, placement: str | None = None) -> TeX:
+    return _placed("figure", body, placement)
+
+
+@Registry.add
+def Table(body: TeX | str, placement: str | None = None) -> TeX:
+    return _placed("table", body, placement)
+
+
+@Registry.add
+def FigureStar(body: TeX | str, placement: str | None = None) -> TeX:
+    return _placed("figure*", body, placement)
+
+
+@Registry.add
+def TableStar(body: TeX | str, placement: str | None = None) -> TeX:
+    return _placed("table*", body, placement)
+
+
+@Registry.add
+def Minipage(width: str, body: TeX | str, align: str | None = None) -> TeX:
+    if align is None:
+        return Environment("minipage", body, (Parameter(width),))
+    return Environment(
+        "minipage",
+        body,
+        (Parameter(align, optional=True), Parameter(width)),
+    )
+
+
+@Registry.add
+@with_package(FLOAT)
+def Restylefloat(typ: str) -> TeX:
+    return ControlSequence("restylefloat", (Parameter(typ),))
+
+
+@Registry.add
+@with_package(FLOAT)
+def Newfloat(typ: str, placement: str, ext: str) -> TeX:
+    return ControlSequence(
+        "newfloat",
+        (Parameter(typ), Parameter(placement), Parameter(ext)),
+    )
+
+
+@Registry.add
+@with_package(FLOATROW)
+def Floatsetup(options: dict[str, str]) -> TeX:
+    return ControlSequence("floatsetup", (Parameter(options),))
+
+
+@Registry.add
+def Multicols(n: int, body: TeX | str) -> TeX:
+    return Environment("multicols", body, (Parameter(str(n)),))
+
+
+@Registry.add
+def Columnbreak() -> TeX:
+    return ControlSequence("columnbreak", ())
+
+
+@Registry.add
+def Titlepage(body: TeX | str) -> TeX:
+    return Environment("titlepage", body)

pytex/commands/font.py

@@ -0,0 +1,138 @@
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..registry import Registry
+
+__all__ = [
+    "Bfseries",
+    "Fontsize",
+    "Footnotesize",
+    "Huge",
+    "HugeBig",
+    "Itshape",
+    "Large",
+    "LargeBig",
+    "LargeMid",
+    "Mdseries",
+    "Normalfont",
+    "Normalsize",
+    "Rmfamily",
+    "Scriptsize",
+    "Scshape",
+    "Selectfont",
+    "Sffamily",
+    "Slshape",
+    "Small",
+    "Tiny",
+    "Ttfamily",
+    "Upshape",
+]
+
+
+@Registry.add
+def Fontsize(size: str, baseline: str) -> TeX:
+    return ControlSequence("fontsize", (Parameter(size), Parameter(baseline)))
+
+
+@Registry.add
+def Selectfont() -> TeX:
+    return ControlSequence("selectfont", ())
+
+
+@Registry.add
+def Rmfamily() -> TeX:
+    return ControlSequence("rmfamily", ())
+
+
+@Registry.add
+def Sffamily() -> TeX:
+    return ControlSequence("sffamily", ())
+
+
+@Registry.add
+def Ttfamily() -> TeX:
+    return ControlSequence("ttfamily", ())
+
+
+@Registry.add
+def Bfseries() -> TeX:
+    return ControlSequence("bfseries", ())
+
+
+@Registry.add
+def Mdseries() -> TeX:
+    return ControlSequence("mdseries", ())
+
+
+@Registry.add
+def Itshape() -> TeX:
+    return ControlSequence("itshape", ())
+
+
+@Registry.add
+def Slshape() -> TeX:
+    return ControlSequence("slshape", ())
+
+
+@Registry.add
+def Scshape() -> TeX:
+    return ControlSequence("scshape", ())
+
+
+@Registry.add
+def Upshape() -> TeX:
+    return ControlSequence("upshape", ())
+
+
+@Registry.add
+def Normalfont() -> TeX:
+    return ControlSequence("normalfont", ())
+
+
+@Registry.add
+def Tiny() -> TeX:
+    return ControlSequence("tiny", ())
+
+
+@Registry.add
+def Scriptsize() -> TeX:
+    return ControlSequence("scriptsize", ())
+
+
+@Registry.add
+def Footnotesize() -> TeX:
+    return ControlSequence("footnotesize", ())
+
+
+@Registry.add
+def Small() -> TeX:
+    return ControlSequence("small", ())
+
+
+@Registry.add
+def Normalsize() -> TeX:
+    return ControlSequence("normalsize", ())
+
+
+@Registry.add
+def Large() -> TeX:
+    return ControlSequence("large", ())
+
+
+@Registry.add
+def LargeMid() -> TeX:
+    return ControlSequence("Large", ())
+
+
+@Registry.add
+def LargeBig() -> TeX:
+    return ControlSequence("LARGE", ())
+
+
+@Registry.add
+def Huge() -> TeX:
+    return ControlSequence("huge", ())
+
+
+@Registry.add
+def HugeBig() -> TeX:
+    return ControlSequence("Huge", ())

pytex/commands/fontawesome.py

@@ -0,0 +1,88 @@
+from pytex.model.empty import Empty
+
+from ..helpers.with_package import with_package
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..packages import FONTAWESOME
+from ..registry import Registry
+
+__all__ = [
+    "FaBookmark",
+    "FaCheckCircle",
+    "FaCog",
+    "FaExclamationCircle",
+    "FaExclamationTriangle",
+    "FaGithub",
+    "FaIcon",
+    "FaInfoCircle",
+    "FaQuestionCircle",
+    "FaVoteYea",
+]
+
+
+@Registry.add
+@with_package(FONTAWESOME)
+def FaIcon(name: str | None) -> TeX:
+    # fontawesome (v4) spells the generic helper lowercase; v5's \faIcon does
+    # not exist here. The v4 package loads via Type1 fonts, so it survives
+    # tectonic's XeTeX engine (fontawesome5's OTF load crashes it).
+    return ControlSequence("faicon", (Parameter(name),)) if name is not None else Empty
+
+
+def _icon(name: str) -> TeX:
+    return ControlSequence(name, ())
+
+
+@Registry.add
+@with_package(FONTAWESOME)
+def FaInfoCircle() -> TeX:
+    return _icon("faInfoCircle")
+
+
+@Registry.add
+@with_package(FONTAWESOME)
+def FaExclamationTriangle() -> TeX:
+    return _icon("faExclamationTriangle")
+
+
+@Registry.add
+@with_package(FONTAWESOME)
+def FaExclamationCircle() -> TeX:
+    return _icon("faExclamationCircle")
+
+
+@Registry.add
+@with_package(FONTAWESOME)
+def FaCheckCircle() -> TeX:
+    return _icon("faCheckCircle")
+
+
+@Registry.add
+@with_package(FONTAWESOME)
+def FaVoteYea() -> TeX:
+    # No \faVoteYea macro in fontawesome v4; use the generic name lookup.
+    return ControlSequence("faicon", (Parameter("vote-yea"),))
+
+
+@Registry.add
+@with_package(FONTAWESOME)
+def FaQuestionCircle() -> TeX:
+    return _icon("faQuestionCircle")
+
+
+@Registry.add
+@with_package(FONTAWESOME)
+def FaBookmark() -> TeX:
+    return _icon("faBookmark")
+
+
+@Registry.add
+@with_package(FONTAWESOME)
+def FaCog() -> TeX:
+    return _icon("faCog")
+
+
+@Registry.add
+@with_package(FONTAWESOME)
+def FaGithub() -> TeX:
+    return _icon("faGithub")

pytex/commands/fontspec.py

@@ -0,0 +1,75 @@
+from ..helpers.with_package import with_package
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..model.raw import Raw
+from ..packages import FONTSPEC
+from ..registry import Registry
+
+__all__ = [
+    "Newfontfamily",
+    "Setfontfamilies",
+    "Setmainfont",
+    "Setmonofont",
+    "Setsansfont",
+]
+
+
+def _opts_to_str(opts: dict[str, str]) -> str:
+    return ",".join(k if v == "" else f"{k}={v}" for k, v in opts.items())
+
+
+@Registry.add
+@with_package(FONTSPEC)
+def Setmainfont(font: str, options: dict[str, str] | None = None) -> TeX:
+    if options is None:
+        return ControlSequence("setmainfont", (Parameter(font),))
+    return ControlSequence(
+        "setmainfont",
+        (Parameter(font), Parameter(Raw(_opts_to_str(options)), optional=True)),
+    )
+
+
+@Registry.add
+@with_package(FONTSPEC)
+def Setsansfont(font: str, options: dict[str, str] | None = None) -> TeX:
+    if options is None:
+        return ControlSequence("setsansfont", (Parameter(font),))
+    return ControlSequence(
+        "setsansfont",
+        (Parameter(font), Parameter(Raw(_opts_to_str(options)), optional=True)),
+    )
+
+
+@Registry.add
+@with_package(FONTSPEC)
+def Setmonofont(font: str, options: dict[str, str] | None = None) -> TeX:
+    if options is None:
+        return ControlSequence("setmonofont", (Parameter(font),))
+    return ControlSequence(
+        "setmonofont",
+        (Parameter(font), Parameter(Raw(_opts_to_str(options)), optional=True)),
+    )
+
+
+@Registry.add
+@with_package(FONTSPEC)
+def Newfontfamily(cmd: str, font: str, options: dict[str, str] | None = None) -> TeX:
+    if options is None:
+        return ControlSequence(
+            "newfontfamily",
+            (Parameter(Raw(cmd)), Parameter(font)),
+        )
+    return ControlSequence(
+        "newfontfamily",
+        (
+            Parameter(Raw(cmd)),
+            Parameter(font),
+            Parameter(Raw(_opts_to_str(options)), optional=True),
+        ),
+    )
+
+
+@Registry.add
+@with_package(FONTSPEC)
+def Setfontfamilies(font: str) -> TeX:
+    return ControlSequence("setfontfamilies", (Parameter(font),))