pytex-preprocessor 0.1.0__py3-none-any.whl

pytex/commands/geometry.py

@@ -0,0 +1,25 @@
+from ..helpers.with_package import with_package
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..packages import GEOMETRY
+from ..registry import Registry
+
+__all__ = ["Geometry", "Newgeometry", "Restoregeometry"]
+
+
+@Registry.add
+@with_package(GEOMETRY)
+def Geometry(options: dict[str, str]) -> TeX:
+    return ControlSequence("geometry", (Parameter(options),))
+
+
+@Registry.add
+@with_package(GEOMETRY)
+def Newgeometry(options: dict[str, str]) -> TeX:
+    return ControlSequence("newgeometry", (Parameter(options),))
+
+
+@Registry.add
+@with_package(GEOMETRY)
+def Restoregeometry() -> TeX:
+    return ControlSequence("restoregeometry", ())

pytex/commands/glossaries.py

@@ -0,0 +1,126 @@
+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 GLOSSARIES
+from ..registry import Registry
+
+__all__ = [
+    "Acrfull",
+    "Acrlong",
+    "Acrshort",
+    "Gls",
+    "Glsenablehyper",
+    "Glspl",
+    "Glsplupper",
+    "Glsupper",
+    "Makeglossaries",
+    "Newacronym",
+    "Newglossaryentry",
+    "Printacronyms",
+    "Printglossary",
+    "Setglossarystyle",
+]
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Makeglossaries() -> TeX:
+    return ControlSequence("makeglossaries", ())
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Newglossaryentry(label: str, fields: dict[str, str]) -> TeX:
+    # Brace each value so commas inside it (common in descriptions) are not
+    # parsed as key=value separators by the glossaries key-val list.
+    opts = ",".join(f"{key}={{{value}}}" for key, value in fields.items())
+    return ControlSequence(
+        "newglossaryentry",
+        (Parameter(label), Parameter(Raw(opts))),
+    )
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Newacronym(label: str, short: str, long: str) -> TeX:
+    return ControlSequence(
+        "newacronym",
+        (Parameter(label), Parameter(short), Parameter(long)),
+    )
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Printglossary(options: dict[str, str] | None = None) -> TeX:
+    if options is None:
+        return ControlSequence("printglossary", ())
+    return ControlSequence(
+        "printglossary",
+        (Parameter(options, optional=True),),
+    )
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Printacronyms(options: dict[str, str] | None = None) -> TeX:
+    if options is None:
+        return ControlSequence("printacronyms", ())
+    return ControlSequence(
+        "printacronyms",
+        (Parameter(options, optional=True),),
+    )
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Gls(label: str) -> TeX:
+    return ControlSequence("gls", (Parameter(label),))
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Glsupper(label: str) -> TeX:
+    return ControlSequence("Gls", (Parameter(label),))
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Glspl(label: str) -> TeX:
+    return ControlSequence("glspl", (Parameter(label),))
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Glsplupper(label: str) -> TeX:
+    return ControlSequence("Glspl", (Parameter(label),))
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Acrshort(label: str) -> TeX:
+    return ControlSequence("acrshort", (Parameter(label),))
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Acrlong(label: str) -> TeX:
+    return ControlSequence("acrlong", (Parameter(label),))
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Acrfull(label: str) -> TeX:
+    return ControlSequence("acrfull", (Parameter(label),))
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Setglossarystyle(name: str) -> TeX:
+    return ControlSequence("setglossarystyle", (Parameter(name),))
+
+
+@Registry.add
+@with_package(GLOSSARIES)
+def Glsenablehyper() -> TeX:
+    return ControlSequence("glsenablehyper", ())

pytex/commands/graphics.py

@@ -0,0 +1,68 @@
+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 GRAPHICX
+from ..registry import Registry
+
+__all__ = ["Graphicspath", "Includegraphics", "Resizebox", "Rotatebox", "Scalebox"]
+
+
+@Registry.add
+@with_package(GRAPHICX)
+def Includegraphics(
+    path: str,
+    width: str | None = None,
+    height: str | None = None,
+    scale: str | None = None,
+    angle: str | None = None,
+    keepaspectratio: bool = False,
+    extra_options: dict[str, str] | None = None,
+) -> TeX:
+    sized = (
+        f"{key}={value}"
+        for key, value in (
+            ("width", width),
+            ("height", height),
+            ("scale", scale),
+            ("angle", angle),
+        )
+        if value is not None
+    )
+    flags = ("keepaspectratio",) if keepaspectratio else ()
+    extra = (f"{k}={v}" for k, v in (extra_options or {}).items())
+    opts = [*sized, *flags, *extra]
+    params = (
+        (Parameter(Raw(",".join(opts)), optional=True), Parameter(path))
+        if opts
+        else (Parameter(path),)
+    )
+    return ControlSequence("includegraphics", params)
+
+
+@Registry.add
+@with_package(GRAPHICX)
+def Graphicspath(*paths: str) -> TeX:
+    inner = "".join(f"{{{p}}}" for p in paths)
+    return ControlSequence("graphicspath", (Parameter(Raw(inner)),))
+
+
+@Registry.add
+@with_package(GRAPHICX)
+def Resizebox(width: str, height: str, body: TeX | str) -> TeX:
+    return ControlSequence(
+        "resizebox",
+        (Parameter(width), Parameter(height), Parameter(body)),
+    )
+
+
+@Registry.add
+@with_package(GRAPHICX)
+def Scalebox(scale: str, body: TeX | str) -> TeX:
+    return ControlSequence("scalebox", (Parameter(scale), Parameter(body)))
+
+
+@Registry.add
+@with_package(GRAPHICX)
+def Rotatebox(angle: str, body: TeX | str) -> TeX:
+    return ControlSequence("rotatebox", (Parameter(angle), Parameter(body)))

pytex/commands/hooks.py

@@ -0,0 +1,58 @@
+from ..helpers.with_package import with_package
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..packages import ETOOLBOX
+from ..registry import Registry
+
+__all__ = [
+    "AtBeginDocument",
+    "AtBeginEnvironment",
+    "AtBeginPage",
+    "AtEndDocument",
+    "AtEndEnvironment",
+    "AtEndOfClass",
+    "AtEndOfPackage",
+]
+
+
+@Registry.add
+def AtBeginDocument(body: TeX | str) -> TeX:
+    return ControlSequence("AtBeginDocument", (Parameter(body),))
+
+
+@Registry.add
+def AtEndDocument(body: TeX | str) -> TeX:
+    return ControlSequence("AtEndDocument", (Parameter(body),))
+
+
+@Registry.add
+@with_package(ETOOLBOX)
+def AtBeginEnvironment(env: str, body: TeX | str) -> TeX:
+    return ControlSequence(
+        "AtBeginEnvironment",
+        (Parameter(env), Parameter(body)),
+    )
+
+
+@Registry.add
+@with_package(ETOOLBOX)
+def AtEndEnvironment(env: str, body: TeX | str) -> TeX:
+    return ControlSequence(
+        "AtEndEnvironment",
+        (Parameter(env), Parameter(body)),
+    )
+
+
+@Registry.add
+def AtBeginPage(body: TeX | str) -> TeX:
+    return ControlSequence("AtBeginPage", (Parameter(body),))
+
+
+@Registry.add
+def AtEndOfPackage(body: TeX | str) -> TeX:
+    return ControlSequence("AtEndOfPackage", (Parameter(body),))
+
+
+@Registry.add
+def AtEndOfClass(body: TeX | str) -> TeX:
+    return ControlSequence("AtEndOfClass", (Parameter(body),))

pytex/commands/hyperref.py

@@ -0,0 +1,57 @@
+from ..helpers.with_package import with_package
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..packages import HYPERREF
+from ..registry import Registry
+
+__all__ = [
+    "Autoref",
+    "Href",
+    "Hyperlink",
+    "Hypersetup",
+    "Hypertarget",
+    "Nolinkurl",
+    "Url",
+]
+
+
+@Registry.add
+@with_package(HYPERREF)
+def Hypersetup(options: dict[str, str]) -> TeX:
+    return ControlSequence("hypersetup", (Parameter(options),))
+
+
+@Registry.add
+@with_package(HYPERREF)
+def Href(url: str, text: TeX | str) -> TeX:
+    return ControlSequence("href", (Parameter(url), Parameter(text)))
+
+
+@Registry.add
+@with_package(HYPERREF)
+def Url(url: str) -> TeX:
+    return ControlSequence("url", (Parameter(url),))
+
+
+@Registry.add
+@with_package(HYPERREF)
+def Nolinkurl(url: str) -> TeX:
+    return ControlSequence("nolinkurl", (Parameter(url),))
+
+
+@Registry.add
+@with_package(HYPERREF)
+def Hyperlink(name: str, text: TeX | str) -> TeX:
+    return ControlSequence("hyperlink", (Parameter(name), Parameter(text)))
+
+
+@Registry.add
+@with_package(HYPERREF)
+def Hypertarget(name: str, text: TeX | str) -> TeX:
+    return ControlSequence("hypertarget", (Parameter(name), Parameter(text)))
+
+
+@Registry.add
+@with_package(HYPERREF)
+def Autoref(name: str) -> TeX:
+    return ControlSequence("autoref", (Parameter(name),))

pytex/commands/lengths.py

@@ -0,0 +1,200 @@
+from ..interface.tex import TeX
+from ..model.control_sequence import ControlSequence, Parameter
+from ..model.length import Length
+from ..model.raw import Raw
+from ..registry import Registry
+
+__all__ = [
+    "Addtolength",
+    "Arraystretch_len",
+    "Baselineskip",
+    "Baselinestretch",
+    "Columnsep",
+    "Columnwidth",
+    "Fill",
+    "Footskip",
+    "Headheight",
+    "Headsep",
+    "Leftmargin",
+    "Linewidth",
+    "Marginparwidth",
+    "Newlength",
+    "Pageheight",
+    "Pagewidth",
+    "Paperheight",
+    "Paperwidth",
+    "Parindent",
+    "Parskip",
+    "Rightmargin",
+    "Setlength",
+    "Settodepth",
+    "Settoheight",
+    "Settowidth",
+    "Tabcolsep",
+    "Textheight",
+    "Textwidth",
+    "Topmargin",
+]
+
+
+@Registry.add
+def Newlength(name: str) -> TeX:
+    return ControlSequence("newlength", (Parameter(Raw(name)),))
+
+
+@Registry.add
+def Setlength(name: str, value: Length | str) -> TeX:
+    expr = value.expr if isinstance(value, Length) else value
+    return ControlSequence("setlength", (Parameter(Raw(name)), Parameter(expr)))
+
+
+@Registry.add
+def Addtolength(name: str, value: Length | str) -> TeX:
+    expr = value.expr if isinstance(value, Length) else value
+    return ControlSequence(
+        "addtolength",
+        (Parameter(Raw(name)), Parameter(expr)),
+    )
+
+
+@Registry.add
+def Settowidth(name: str, body: TeX | str) -> TeX:
+    return ControlSequence(
+        "settowidth",
+        (Parameter(Raw(name)), Parameter(body)),
+    )
+
+
+@Registry.add
+def Settoheight(name: str, body: TeX | str) -> TeX:
+    return ControlSequence(
+        "settoheight",
+        (Parameter(Raw(name)), Parameter(body)),
+    )
+
+
+@Registry.add
+def Settodepth(name: str, body: TeX | str) -> TeX:
+    return ControlSequence(
+        "settodepth",
+        (Parameter(Raw(name)), Parameter(body)),
+    )
+
+
+def _const(name: str) -> Length:
+    return Length(f"\\{name}")
+
+
+@Registry.add
+def Textwidth() -> Length:
+    return _const("textwidth")
+
+
+@Registry.add
+def Textheight() -> Length:
+    return _const("textheight")
+
+
+@Registry.add
+def Linewidth() -> Length:
+    return _const("linewidth")
+
+
+@Registry.add
+def Columnwidth() -> Length:
+    return _const("columnwidth")
+
+
+@Registry.add
+def Columnsep() -> Length:
+    return _const("columnsep")
+
+
+@Registry.add
+def Paperwidth() -> Length:
+    return _const("paperwidth")
+
+
+@Registry.add
+def Paperheight() -> Length:
+    return _const("paperheight")
+
+
+@Registry.add
+def Pagewidth() -> Length:
+    return _const("pagewidth")
+
+
+@Registry.add
+def Pageheight() -> Length:
+    return _const("pageheight")
+
+
+@Registry.add
+def Baselineskip() -> Length:
+    return _const("baselineskip")
+
+
+@Registry.add
+def Baselinestretch() -> Length:
+    return _const("baselinestretch")
+
+
+@Registry.add
+def Parindent() -> Length:
+    return _const("parindent")
+
+
+@Registry.add
+def Parskip() -> Length:
+    return _const("parskip")
+
+
+@Registry.add
+def Topmargin() -> Length:
+    return _const("topmargin")
+
+
+@Registry.add
+def Leftmargin() -> Length:
+    return _const("leftmargin")
+
+
+@Registry.add
+def Rightmargin() -> Length:
+    return _const("rightmargin")
+
+
+@Registry.add
+def Footskip() -> Length:
+    return _const("footskip")
+
+
+@Registry.add
+def Headheight() -> Length:
+    return _const("headheight")
+
+
+@Registry.add
+def Headsep() -> Length:
+    return _const("headsep")
+
+
+@Registry.add
+def Marginparwidth() -> Length:
+    return _const("marginparwidth")
+
+
+@Registry.add
+def Tabcolsep() -> Length:
+    return _const("tabcolsep")
+
+
+@Registry.add
+def Arraystretch_len() -> Length:
+    return _const("arraystretch")
+
+
+@Registry.add
+def Fill() -> Length:
+    return _const("fill")

pytex/commands/listings.py

@@ -0,0 +1,63 @@
+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 ..model.raw import Raw
+from ..packages import LISTINGS
+from ..registry import Registry
+
+__all__ = ["Lstdefinestyle", "Lstinline", "Lstinputlisting", "Lstlisting", "Lstset"]
+
+
+def _render_value(value: object) -> str:
+    if isinstance(value, TeX):
+        return value.rendered
+    return str(value)
+
+
+def _opts_to_str(opts: dict[str, TeX | str]) -> str:
+    return ",".join(f"{k}={_render_value(v)}" for k, v in opts.items())
+
+
+@Registry.add
+@with_package(LISTINGS)
+def Lstset(options: dict[str, TeX | str]) -> TeX:
+    return ControlSequence("lstset", (Parameter(Raw(_opts_to_str(options))),))
+
+
+@Registry.add
+@with_package(LISTINGS)
+def Lstdefinestyle(name: str, options: dict[str, TeX | str]) -> TeX:
+    return ControlSequence(
+        "lstdefinestyle",
+        (Parameter(name), Parameter(Raw(_opts_to_str(options)))),
+    )
+
+
+@Registry.add
+@with_package(LISTINGS)
+def Lstinputlisting(path: str, options: dict[str, TeX | str] | None = None) -> TeX:
+    if options is None:
+        return ControlSequence("lstinputlisting", (Parameter(path),))
+    return ControlSequence(
+        "lstinputlisting",
+        (
+            Parameter(Raw(_opts_to_str(options)), optional=True),
+            Parameter(path),
+        ),
+    )
+
+
+@Registry.add
+@with_package(LISTINGS)
+def Lstinline(body: str, delim: str = "|") -> TeX:
+    return Raw(f"\\lstinline{delim}{body}{delim}")
+
+
+@Registry.add
+@with_package(LISTINGS)
+def Lstlisting(body: str, options: dict[str, TeX | str] | None = None) -> TeX:
+    params: tuple[Parameter, ...] = ()
+    if options:
+        params = (Parameter(Raw(_opts_to_str(options)), optional=True),)
+    return Environment("lstlisting", body, params)

pytex/commands/mdframed.py

@@ -0,0 +1,43 @@
+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 ..model.raw import Raw
+from ..packages import MDFRAMED
+from ..registry import Registry
+
+__all__ = ["Mdfdefinestyle", "Mdframed", "Newmdenv"]
+
+
+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(MDFRAMED)
+def Mdframed(body: TeX | str, options: dict[str, str] | None = None) -> TeX:
+    params: tuple[Parameter, ...] = ()
+    if options:
+        params = (Parameter(Raw(_opts_to_str(options)), optional=True),)
+    return Environment("mdframed", body, params)
+
+
+@Registry.add
+@with_package(MDFRAMED)
+def Mdfdefinestyle(name: str, options: dict[str, str]) -> TeX:
+    return ControlSequence(
+        "mdfdefinestyle",
+        (Parameter(name), Parameter(Raw(_opts_to_str(options)))),
+    )
+
+
+@Registry.add
+@with_package(MDFRAMED)
+def Newmdenv(name: str, options: dict[str, str]) -> TeX:
+    return ControlSequence(
+        "newmdenv",
+        (
+            Parameter(Raw(_opts_to_str(options)), optional=True),
+            Parameter(name),
+        ),
+    )

pytex/commands/picture.py

@@ -0,0 +1,32 @@
+from ..interface.tex import TeX
+from ..model.concat import Concat
+from ..model.raw import Raw
+from ..registry import Registry
+
+__all__ = ["Picture", "Put"]
+
+
+@Registry.add
+def Picture(
+    width: str,
+    height: str,
+    body: TeX | str,
+    x_offset: str = "0",
+    y_offset: str = "0",
+) -> TeX:
+    """`\\begin{picture}(W,H)(x,y) ... \\end{picture}` — non-standard arg syntax."""
+    return Concat(
+        Raw(f"\\begin{{picture}}({width},{height})({x_offset},{y_offset})"),
+        body,
+        Raw("\\end{picture}"),
+    )
+
+
+@Registry.add
+def Put(x: str, y: str, body: TeX | str) -> TeX:
+    """`\\put(x,y){body}` — picture-mode placement."""
+    return Concat(
+        Raw(f"\\put({x},{y}){{"),
+        body,
+        Raw("}"),
+    )