gmpl-tex 0.1.0__tar.gz

gmpl_tex-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: gmpl-tex
+Version: 0.1.0
+Summary: Convert GMPL (GNU MathProg) models into LaTeX.
+Requires-Python: >=3.10
+Requires-Dist: lark>=1.1
+Description-Content-Type: text/markdown
+
+# gmpl-tex
+
+Convert a subset of **GMPL** (GNU MathProg) optimization models into **LaTeX**, so
+the constraints, sets, parameters, variables and objectives you wrote for a solver
+can go straight into a paper with readable, renamed symbols.
+
+The tool works in two phases so you stay in control of the notation:
+
+1. **Lookup-table generation** - parse `model.mod` into a JSON table listing every
+   set, parameter, variable, constraint and objective name. Each name maps to a
+   label you can edit.
+2. **LaTeX generation** - render the model to LaTeX, substituting your edited
+   labels from the JSON table.
+
+## Install
+
+No Python project setup required for users - pick whichever you have:
+
+```bash
+# with uv (no install, runs in a throwaway environment)
+uvx --from git+https://github.com/<you>/gmpl-tex gmpl-tex --help
+
+# with pipx (installs the gmpl-tex command onto your PATH)
+pipx install git+https://github.com/<you>/gmpl-tex
+
+# with plain pip, into a virtual environment
+pip install git+https://github.com/<you>/gmpl-tex
+```
+
+## Usage
+
+```text
+gmpl-tex model.mod [lookup.json] --json
+gmpl-tex model.mod [lookup.json] [output.tex] --latex
+```
+
+A full run, start to finish:
+
+```bash
+# 1. generate the editable lookup table (writes model.json)
+gmpl-tex model.mod --json
+
+# 2. open model.json and edit the label on the right-hand side of each entry,
+#    e.g. "finishTime": "fTime"
+
+# 3. render LaTeX using your edited labels (writes model.tex)
+gmpl-tex model.mod model.json --latex
+```
+
+If you skip step 1 and run `gmpl-tex model.mod --latex` directly, a default table
+is created automatically (labels equal to the raw names) and used. If a
+`model.json` already exists next to the model, it is reused as-is and never
+overwritten.
+
+An example model is included under [`examples/model.mod`](examples/model.mod).
+
+## Requirements
+
+- Python 3.10 or newer
+- [`lark`](https://github.com/lark-parser/lark) (installed automatically)

gmpl_tex-0.1.0/README.md

@@ -0,0 +1,60 @@
+# gmpl-tex
+
+Convert a subset of **GMPL** (GNU MathProg) optimization models into **LaTeX**, so
+the constraints, sets, parameters, variables and objectives you wrote for a solver
+can go straight into a paper with readable, renamed symbols.
+
+The tool works in two phases so you stay in control of the notation:
+
+1. **Lookup-table generation** - parse `model.mod` into a JSON table listing every
+   set, parameter, variable, constraint and objective name. Each name maps to a
+   label you can edit.
+2. **LaTeX generation** - render the model to LaTeX, substituting your edited
+   labels from the JSON table.
+
+## Install
+
+No Python project setup required for users - pick whichever you have:
+
+```bash
+# with uv (no install, runs in a throwaway environment)
+uvx --from git+https://github.com/<you>/gmpl-tex gmpl-tex --help
+
+# with pipx (installs the gmpl-tex command onto your PATH)
+pipx install git+https://github.com/<you>/gmpl-tex
+
+# with plain pip, into a virtual environment
+pip install git+https://github.com/<you>/gmpl-tex
+```
+
+## Usage
+
+```text
+gmpl-tex model.mod [lookup.json] --json
+gmpl-tex model.mod [lookup.json] [output.tex] --latex
+```
+
+A full run, start to finish:
+
+```bash
+# 1. generate the editable lookup table (writes model.json)
+gmpl-tex model.mod --json
+
+# 2. open model.json and edit the label on the right-hand side of each entry,
+#    e.g. "finishTime": "fTime"
+
+# 3. render LaTeX using your edited labels (writes model.tex)
+gmpl-tex model.mod model.json --latex
+```
+
+If you skip step 1 and run `gmpl-tex model.mod --latex` directly, a default table
+is created automatically (labels equal to the raw names) and used. If a
+`model.json` already exists next to the model, it is reused as-is and never
+overwritten.
+
+An example model is included under [`examples/model.mod`](examples/model.mod).
+
+## Requirements
+
+- Python 3.10 or newer
+- [`lark`](https://github.com/lark-parser/lark) (installed automatically)

gmpl_tex-0.1.0/examples/model.mod

@@ -0,0 +1,44 @@
+# A TRANSPORTATION PROBLEM
+#
+# This problem finds a least cost shipping schedule that meets
+# requirements at markets and supplies at factories.
+#
+# References:
+# Dantzig G B, "Linear Programming and Extensions."
+# Princeton University Press, Princeton, New Jersey, 1963,
+# Chapter 3-3.
+set I;
+/* canning plants */
+set J;
+/* markets */
+param a{i in I};
+/* capacity of plant i in cases */
+param b{j in J};
+/* demand at market j in cases */
+param d{i in I, j in J};
+/* distance in thousands of miles */
+param f;
+/* freight in dollars per case per thousand miles */
+param c{i in I, j in J} := f * d[i,j] / 1000;
+/* transport cost in thousands of dollars per case */
+var x{i in I, j in J} >= 0;
+/* shipment quantities in cases */
+minimize cost: sum{i in I, j in J} c[i,j] * x[i,j];
+/* total transportation costs in thousands of dollars */
+s.t. supply{i in I}: sum{j in J} x[i,j] <= a[i];
+/* observe supply limit at plant i */
+s.t. demand{j in J}: sum{i in I} x[i,j] >= b[j];
+/* satisfy demand at market j */
+data;
+set I := Seattle San-Diego;
+set J := New-York Chicago Topeka;
+param a := Seattle 350
+San-Diego 600;
+param b := New-York 325
+Chicago 300
+Topeka 275;
+param d : New-York Chicago Topeka :=
+Seattle 2.5 1.7 1.8
+San-Diego 2.5 1.8 1.4 ;
+param f := 90;
+end;

gmpl_tex-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "gmpl-tex"
+version = "0.1.0"
+description = "Convert GMPL (GNU MathProg) models into LaTeX."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["lark>=1.1"]
+
+[project.scripts]
+gmpl-tex = "gmpltex.main:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/gmpltex"]
+
+# Guarantee the grammar travels inside the wheel even if
+# the default file discovery ever changes.
+[tool.hatch.build.targets.wheel.force-include]
+"src/gmpltex/grammar.lark" = "gmpltex/grammar.lark"

gmpl_tex-0.1.0/src/gmpltex/DataModels/RenderModels.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass
+from abc import ABC
+
+
+@dataclass
+class Section(ABC):
+    """Base for every renderable declaration. `line` is the 1-based source line,
+    used for the `% Line N` comments in the generated LaTeX."""
+    line: int | None
+
+
+@dataclass
+class AttributedStatement(Section):
+    name: str
+    domain: str | None
+    attributes: list[str]
+
+
+@dataclass
+class Set(AttributedStatement):
+    pass
+
+@dataclass
+class Parameter(AttributedStatement):
+    pass
+
+
+@dataclass
+class Variable(AttributedStatement):
+    pass
+
+
+@dataclass
+class Constraint(Section):
+    """A relation rendered as a labelled equation.
+
+        single bound:  lhs  op_left  rhs
+        double bound:  lhs  op_left  middle  op_right  rhs   (e.g. lb <= e <= ub)
+
+    `middle` / `op_right` stay None for a single-sided constraint.
+    """
+    name: str
+    domain: str | None
+    lhs: str
+    op_left: str
+    rhs: str
+    middle: str | None = None
+    op_right: str | None = None
+
+
+@dataclass
+class Objective(Section):
+    verb: str
+    name: str
+    domain: str | None
+    formula: str
+
+
+@dataclass
+class Model:
+    sets:        list[Set]
+    parameters:  list[Parameter]
+    variables:   list[Variable]
+    constraints: list[Constraint]
+    objectives:  list[Objective]

gmpl_tex-0.1.0/src/gmpltex/Modules/LatexAssembler.py

@@ -0,0 +1,144 @@
+from ..DataModels.RenderModels import *
+
+_PREAMBLE = """\
+\\documentclass{article}
+\\usepackage[utf8]{inputenc}
+\\usepackage{amsmath}
+\\usepackage{amssymb}
+\\usepackage{xcolor}
+
+\\begin{document}
+"""
+
+def _wrap_into_latex_skeleton(body: str) -> str:
+    """Wrap math blocks in a compilable LaTeX document skeleton."""
+    return _PREAMBLE + body + "\n\\end{document}"
+
+
+def assemble_latex(model: Model, standalone: bool = True) -> str:
+    """Render a whole model to LaTeX.
+
+    With ``standalone`` (the default) the output is a compilable document --
+    documentclass, packages and ``document`` environment included. Pass
+    ``standalone=False`` to emit only the math blocks, e.g. for \\input-ing into
+    an existing paper.
+    """
+    sections: list[str] = []
+
+    sections.append(f"\\section{{Input data}}\n")
+    sections.append(f"\\subsection{{Sets}}\n")
+    sections.append(set_param_block(model.sets)) # type: ignore
+
+    sections.append(f"\\subsection{{Parameters}}\n")
+    sections.append(set_param_block(model.parameters)) # type: ignore
+
+    sections.append(f"\\section{{Model}}\n")
+    sections.append(f"\\subsection{{Variables}}\n")
+    sections.append(variables_block(model.variables))
+
+    sections.append(f"\\subsection{{Constraints}}\n")
+    sections.append(constraints_block(model.constraints))
+
+    sections.append(f"\\subsection{{Objectives}}\n")
+    sections.append(objectives_block(model.objectives))
+
+    body = "\n".join(sections)
+
+    return _wrap_into_latex_skeleton(body) if standalone else body
+
+
+def itemize_block(items: list[AttributedStatement]) -> str:
+    if not items:
+        return ""
+    
+    list_items = "\n".join(
+        f"% Line {item.line}\n"
+        "\\item $" + item.name
+        + ", \\quad ".join(
+            [f"{attr}" for attr in item.attributes]
+            + ([item.domain] if item.domain else [])
+        ) + "$"
+        for item in items
+    )
+
+    return f"""\
+\\begin{{itemize}}
+{list_items}
+\\end{{itemize}}
+"""
+
+
+def math_block(items: list[AttributedStatement]) -> str:
+    """Render set or parameter declarations, one display-math block each.
+
+    Both share the same shape (name, optional attributes, optional domain),
+    so sets and parameters go through here.
+    """
+    blocks = []
+    for item in items:
+        attrs = [a for a in item.attributes if a]
+        content = ", \n\\quad ".join(f"{item.name} {attr}" for attr in attrs) if attrs else item.name
+        if item.domain:
+            content += f",\n\\quad {item.domain}"
+        blocks.append(f"""\
+% Line {item.line}
+\\[
+{content}
+\\]
+""")
+    return "\n".join(blocks)
+
+
+def set_param_block(items: list[AttributedStatement]) -> str:
+    
+    if not items:
+        return ""
+
+    blocks = []
+    declarations = [i for i in items if not any(":=" in a for a in (i.attributes or []))]
+    definitions  = [i for i in items if any(":=" in a for a in (i.attributes or []))]
+
+    if declarations:
+        blocks.append(itemize_block(declarations))
+        
+    if definitions:
+        blocks.append(math_block(definitions))
+
+    return "\n".join(blocks)
+
+
+def variables_block(variables: list[Variable]) -> str:
+    """Render all variable declarations as a single itemize list."""
+    return itemize_block(variables) # type: ignore
+
+
+def constraints_block(constraints: list[Constraint]) -> str:
+    """Render each constraint as a labelled equation."""
+    blocks = []
+    for c in constraints:
+        blocks.append(f"""\
+% Line {c.line}
+\\begin{{equation}}
+\\label{{Eq:{c.name}}}
+{c.lhs}
+{c.op_left} 
+{c.middle + "\n" if c.middle else ""} {c.op_right if c.op_right else ""} {c.rhs}
+{c.domain + "\n" if c.domain else ""}\\end{{equation}}
+""")
+    return "\n".join(blocks)
+
+
+def objectives_block(objectives: list[Objective]) -> str:
+    """Render each objective as a labelled equation (formula → sense)."""
+    blocks = []
+    for obj in objectives:
+        blocks.append(f"""\
+% Line {obj.line}
+\\begin{{equation}}
+\\label{{Eq:{obj.name}}}
+{obj.formula}
+\\to
+{obj.verb}
+\\end{{equation}}
+""")
+    return "\n".join(blocks)