gamspy 1.18.1__tar.gz → 1.18.3__tar.gz

{gamspy-1.18.1 → gamspy-1.18.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gamspy
-Version: 1.18.1
+Version: 1.18.3
 Summary: Python-based algebraic modeling interface to GAMS
 Author-email: GAMS Development Corporation <support@gams.com>
 Project-URL: homepage, https://gams.com/sales/gamspy_facts/
@@ -31,8 +31,8 @@ Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: gamsapi<53.0.0,>=52.1.0
-Requires-Dist: gamspy_base<53.0.0,>=52.1.0
+Requires-Dist: gamsapi<53.0.0,>=52.2.0
+Requires-Dist: gamspy_base<53.0.0,>=52.2.0
 Requires-Dist: pandas<2.4,>=2.2.2
 Requires-Dist: pydantic>=2.0
 Requires-Dist: requests>=2.28.0

{gamspy-1.18.1 → gamspy-1.18.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gamspy"
-version = "1.18.1"
+version = "1.18.3"
 authors = [
   { name = "GAMS Development Corporation", email = "support@gams.com" },
 ]
@@ -36,8 +36,8 @@ classifiers = [
   "Operating System :: Microsoft :: Windows",
 ]
 dependencies = [
-  "gamsapi >= 52.1.0, < 53.0.0",
-  "gamspy_base >= 52.1.0, < 53.0.0",
+  "gamsapi >= 52.2.0, < 53.0.0",
+  "gamspy_base >= 52.2.0, < 53.0.0",
   "pandas >= 2.2.2, < 2.4",
   "pydantic >= 2.0",
   "requests >= 2.28.0",

{gamspy-1.18.1 → gamspy-1.18.3}/src/gamspy/_algebra/domain.py

@@ -90,4 +90,4 @@ class Domain:
         -------
         str
         """
-        return utils._get_domain_str(self.sets)[1:-1]
+        return utils._get_domain_str(self.sets, latex=True)[1:-1]

{gamspy-1.18.1 → gamspy-1.18.3}/src/gamspy/_algebra/expression.py

@@ -234,7 +234,7 @@ def create_latex_expression(root_node: Expression) -> str:
             if node.right is not None:
                 s1.append(node.right)
 
-    # 2. Build the GAMS expression
+    # 2. Build the LaTeX expression
     eval_stack: list[tuple[str, float]] = []
     for node in reversed(post_order_nodes):
         if not isinstance(node, Expression):

{gamspy-1.18.1 → gamspy-1.18.3}/src/gamspy/_algebra/operation.py

@@ -96,8 +96,15 @@ class Operation(operable.Operable):
         """
         assert self.container is not None
         temp_name = "a" + utils._get_unique_name()
+        domain: list[Set | Alias] = []
+        for elem in self.domain:
+            if hasattr(elem, "dimension") and elem.dimension > 1:
+                domain.extend(elem.domain)
+            else:
+                domain.append(elem)
+
         temp_param = syms.Parameter._constructor_bypass(
-            self.container, temp_name, self.domain
+            self.container, temp_name, domain
         )
         temp_param[...] = self
         del self.container.data[temp_name]
@@ -756,7 +763,7 @@ class Ord(operable.Operable):
         -------
         str
         """
-        return f"ord({self._symbol.name})"
+        return f"ord({self._symbol._latex_name})"
 
 
 class Card(operable.Operable):
@@ -835,4 +842,4 @@ class Card(operable.Operable):
         -------
         str
         """
-        return f"card({self._symbol.name})"
+        return f"card({self._symbol._latex_name})"

{gamspy-1.18.1 → gamspy-1.18.3}/src/gamspy/_cli/cli.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import typer
 
-from . import gdx, install, list, probe, retrieve, run, show, uninstall
+from . import gdx, install, list, mps2gms, probe, retrieve, run, show, uninstall
 
 app = typer.Typer(
     rich_markup_mode="rich",
@@ -16,6 +16,7 @@ app.add_typer(retrieve.app, name="retrieve")
 app.add_typer(run.app, name="run")
 app.add_typer(show.app, name="show")
 app.add_typer(uninstall.app, name="uninstall")
+app.command(name="mps2gms")(mps2gms.mps2gms)
 
 
 def version_callback(value: bool):

gamspy-1.18.3/src/gamspy/_cli/mps2gms.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import os
+import platform
+import subprocess
+from pathlib import Path  # noqa: TC003
+from typing import Annotated
+
+import gamspy_base
+import typer
+
+# Valid values for categorical parameters based on help string
+VALID_YN = {"0", "N", "1", "Y"}
+VALID_DUPLICATES = {"NOCHECK", "ADD", "IGNORE", "ERROR"}
+VALID_ORIGNAMES = {"NO", "MODIFIED", "ALL"}
+VALID_CONVERTSENSE = {"0", "N", "1", "Y", "MIN", "-1", "MAX"}
+
+
+# Completion functions for Typer
+def complete_yn(ctx: typer.Context, incomplete: str):
+    return [v for v in VALID_YN if v.lower().startswith(incomplete.lower())]
+
+
+def complete_duplicates(ctx: typer.Context, incomplete: str):
+    return [v for v in VALID_DUPLICATES if v.lower().startswith(incomplete.lower())]
+
+
+def complete_orignames(ctx: typer.Context, incomplete: str):
+    return [v for v in VALID_ORIGNAMES if v.lower().startswith(incomplete.lower())]
+
+
+def complete_convertsense(ctx: typer.Context, incomplete: str):
+    return [v for v in VALID_CONVERTSENSE if v.lower().startswith(incomplete.lower())]
+
+
+def mps2gms(
+    input_file: Annotated[
+        Path, typer.Argument(help="MPS or LP file to translate.", exists=True)
+    ],
+    gdx_file: Annotated[
+        Path | None, typer.Argument(help="Name of GDX output file.")
+    ] = None,
+    gms_file: Annotated[
+        Path | None, typer.Argument(help="Name of GAMS program output file.")
+    ] = None,
+    py_file: Annotated[
+        str | None, typer.Option("--py", help="Name of GAMSPy program output file.")
+    ] = None,
+    dec_file: Annotated[
+        str | None, typer.Option("--dec", help="DEC file for decomposition info.")
+    ] = None,
+    column_int_vars_binary: Annotated[
+        str | None,
+        typer.Option(
+            "--columnintvarsarebinary",
+            help="Integer variables appearing first are binary.",
+            autocompletion=complete_yn,
+        ),
+    ] = None,
+    duplicates: Annotated[
+        str | None,
+        typer.Option(
+            help="How to handle multiple coefficients.",
+            autocompletion=complete_duplicates,
+        ),
+    ] = None,
+    orignames: Annotated[
+        str | None,
+        typer.Option(
+            help="Whether to make original names available.",
+            autocompletion=complete_orignames,
+        ),
+    ] = None,
+    stageshift: Annotated[
+        int | None, typer.Option(help="Shift block numbers by this integer.")
+    ] = None,
+    convertsense: Annotated[
+        str | None,
+        typer.Option(
+            help="Convert the objective function sense.",
+            autocompletion=complete_convertsense,
+        ),
+    ] = None,
+):
+    """
+    Translates an MPS or LP file into equivalent generic GAMS and GAMSPy programs.
+    Defaults to writing .py and .gdx files if no outputs are specified.
+    """
+    binary_name = "mps2gms.exe" if platform.system() == "Windows" else "mps2gms"
+    MPS2GMS_PATH = os.path.join(gamspy_base.directory, binary_name)
+
+    if not os.path.exists(MPS2GMS_PATH):
+        typer.echo(f"Binary not found: {MPS2GMS_PATH}", err=True)
+        raise typer.Exit(code=1)
+
+    # Determine default names based on input stem
+    input_name = input_file.with_suffix("")
+    actual_gdx = gdx_file if gdx_file else f"{input_name}.gdx"
+    actual_py = py_file if py_file else f"{input_name}.py"
+
+    # mps2gms <input> <gdx>
+    cmd = [MPS2GMS_PATH, str(input_file), str(actual_gdx)]
+
+    # If gms_file is provided, add it as the third positional;
+    # otherwise, explicitly disable GMS output to prioritize py/gdx.
+    if gms_file:
+        cmd.append(str(gms_file))
+    else:
+        cmd.append("GMS=")
+
+    # Construct key=value parameters for the binary call
+    params = {
+        "PY": actual_py,
+        "DEC": dec_file,
+        "COLUMNINTVARSAREBINARY": column_int_vars_binary,
+        "DUPLICATES": duplicates,
+        "ORIGNAMES": orignames,
+        "STAGESHIFT": stageshift,
+        "CONVERTSENSE": convertsense,
+    }
+
+    for key, value in params.items():
+        if value is not None:
+            cmd.append(f"{key}={value}")
+
+    print(f"Running command: {' '.join(cmd)}")
+    result = subprocess.run(cmd, text=True)
+    raise typer.Exit(code=result.returncode)

{gamspy-1.18.1 → gamspy-1.18.3}/src/gamspy/_container.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import atexit
 import os
 import platform
+import re
 import shutil
 import signal
 import sys
@@ -42,6 +43,7 @@ if TYPE_CHECKING:
         Model,
         Parameter,
         Set,
+        UniverseAlias,
         Variable,
     )
     from gamspy._algebra.expression import Expression
@@ -139,6 +141,7 @@ class Container(gt.Container):
         self.output = output
         self._gams_string = ""
         self.models: dict[str, Model] = {}
+        self._mpsge_models: list[str] = []
         if IS_MIRO_INIT:
             atexit.register(self._write_miro_files)
 
@@ -838,6 +841,14 @@ class Container(gt.Container):
 
         for _, symbol in self:
             symbol.modified = False
+
+        # Unfortunately MPSGE requires a dirty trick
+        pattern = re.compile(r"^\$sysInclude\s+mpsgeset\s+(\w+)\s*$", re.MULTILINE)
+        match = pattern.search(gams_code)
+        if match:
+            model_name = match.group(1)
+            self._mpsge_models.append(model_name.lower())
+
         self._unsaved_statements = []
 
     def close(self) -> None:
@@ -888,6 +899,37 @@ class Container(gt.Container):
 
         return gp.Alias(self, name, alias_with)
 
+    def addUniverseAlias(self, name: str | None = None) -> UniverseAlias:
+        """
+        Creates a new UniverseAlias and adds it to the container
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the universe alias.
+
+        Returns
+        -------
+        UniverseAlias
+
+        Raises
+        ------
+        ValueError
+            If there is symbol with same name but different type in the
+            Container
+
+        Examples
+        --------
+        >>> import gamspy as gp
+        >>> m = gp.Container()
+        >>> a = m.addUniverseAlias("a")
+
+        """
+        if name is None:
+            name = self._get_symbol_name(prefix="u")
+
+        return gp.UniverseAlias(self, name)
+
     def addSet(
         self,
         name: str | None = None,
@@ -1099,7 +1141,7 @@ class Container(gt.Container):
         self,
         name: str | None = None,
         type: str | EquationType = "regular",
-        domain: Sequence[Set | Alias | str] | Set | Alias | str | None = None,
+        domain: Sequence[Set | Alias] | Set | Alias | None = None,
         definition: Variable | Operation | Expression | None = None,
         records: Any | None = None,
         domain_forwarding: bool | list[bool] = False,
@@ -1117,7 +1159,7 @@ class Container(gt.Container):
             Name of the equation. Name is autogenerated by default.
         type : str
             Type of the equation. "regular" by default.
-        domain : Sequence[Set | Alias | str] | Set | Alias | str, optional
+        domain : Sequence[Set | Alias] | Set | Alias, optional
             Domain of the variable.
         definition: Expression, optional
             Definition of the equation.

{gamspy-1.18.1 → gamspy-1.18.3}/src/gamspy/_convert.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import logging
 import os
 import subprocess
 from collections.abc import Sequence
@@ -28,14 +27,6 @@ if TYPE_CHECKING:
 
     SymbolType: TypeAlias = Alias | Set | Parameter | Variable | Equation
 
-logger = logging.getLogger("CONVERTER")
-logger.setLevel(logging.INFO)
-stream_handler = logging.StreamHandler()
-stream_handler.setLevel(logging.INFO)
-formatter = logging.Formatter("[%(name)s - %(levelname)s] %(message)s")
-stream_handler.setFormatter(formatter)
-logger.addHandler(stream_handler)
-
 GAMS_JACOBIAN_TEMPLATE = """$onEmpty
 Set
    i        'equations index'
@@ -388,9 +379,9 @@ class GamsConverter:
         self.path = path
         self.options = options
         self.dump_gams_state = dump_gams_state
-        self.gdx_path = str((path / f"{model.name}_data.gdx").resolve())
-        self.gms_path = str((path / f"{model.name}.gms").resolve())
-        self.g00_path = str((path / f"{model.name}.g00").resolve())
+        self.gdx_path = path / f"{model.name}_data.gdx"
+        self.gms_path = path / f"{model.name}.gms"
+        self.g00_path = path / f"{model.name}.g00"
 
     def get_definitions(self) -> list[str]:
         definitions = []
@@ -438,8 +429,8 @@ class GamsConverter:
             em_name = self.model._external_module
             em_file = self.model._external_module_file
             declarations.append(f"File {em_file} /{em_name}/;")
-            logger.info("Converter will not copy external module files")
-            logger.info(
+            print("Converter will not copy external module files")
+            print(
                 f"You need to ensure your external module is accessible from {self.path}"
             )
 
@@ -482,7 +473,9 @@ class GamsConverter:
         with open(self.gms_path, "w", encoding="utf-8") as file:
             file.write(gams_string)
 
-        logger.info(f"GAMS (.gms) file has been generated under {self.gms_path}")
+        print("=" * 80)
+        print(f"GAMS (.gms) file has been generated under {self.gms_path}")
+        print("=" * 80)
 
 
 TABLE_HEADER = """\\begin{tabularx}{\\textwidth}{| l | l | X |}
@@ -496,7 +489,7 @@ TABLE_FOOTER = "\\hline\n\\end{tabularx}"
 
 
 class LatexConverter:
-    def __init__(self, model: Model, path: Path) -> None:
+    def __init__(self, model: Model, path: Path, rename: dict[str, str] | None) -> None:
         os.makedirs(path, exist_ok=True)
         self.model = model
         self.container = model.container
@@ -512,11 +505,21 @@ class LatexConverter:
                     ):
                         symbols.append(elem.name)
 
+        for name in self.model._autogen_symbols:
+            if name in symbols:
+                symbols.remove(name)
+
         self.symbols = sorted(symbols, key=list(self.container.data.keys()).index)
 
-        for name in self.model._autogen_symbols:
-            if name in self.symbols:
-                self.symbols.remove(name)
+        if rename is not None:
+            for name, latex_name in rename.items():
+                try:
+                    symbol = self.container[name]
+                    symbol._latex_name = latex_name
+                except KeyError as e:
+                    raise KeyError(
+                        f"`{name}` does not exist in the Container. You can only rename symbols that already exist in the container."
+                    ) from e
 
         self.header = self.get_header()
         self.set_header = "\\subsection*{Sets}"
@@ -551,8 +554,9 @@ class LatexConverter:
         if self.model._objective is None:
             ...
         elif isinstance(self.model._objective, syms.Variable):
+            var_name = self.model._objective._latex_name
             latex_strs.append(
-                f"\\textbf{{{str(self.model.sense).lower()}}} ${self.model._objective_variable.name}$\\\\"  # type: ignore
+                f"\\textbf{{{str(self.model.sense).lower()}}} ${var_name}$\\\\"
             )
             latex_strs.append("\\textbf{s.t.}")
         else:
@@ -572,26 +576,35 @@ class LatexConverter:
         with open(self.tex_path, "w", encoding="utf-8") as file:  # Write the TEX file
             file.write(latex_str)
 
-        logger.info(
+        print("=" * 80)
+        print(
             f"LaTeX (.tex) file has been generated under {os.path.join(self.path, self.model.name + '.tex')}"
         )
+        print("=" * 80)
 
         self.latex_str = latex_str
 
     def to_pdf(self) -> None:
-        process = subprocess.run(["pdflatex", "-v"])
-        if process.returncode:
+        try:
+            subprocess.run(["xelatex", "-version"], check=True, text=True)
+        except subprocess.CalledProcessError as e:
             raise ValidationError(
-                "`pdflatex` is required to generate the pdf! Please install `pdflatex` and add it to the path."
+                "`xelatex` is required to generate the pdf! Please install `xelatex` and add it to the path."
+            ) from e
+
+        try:
+            subprocess.run(
+                [
+                    "xelatex",
+                    "-verbose",
+                    f"-output-directory={self.path}",
+                    self.tex_path,
+                ],
+                check=True,
+                text=True,
             )
-
-        process = subprocess.run(
-            ["pdflatex", f"-output-directory={self.path}", self.tex_path],
-            capture_output=True,
-            text=True,
-        )
-        if process.returncode:
-            raise LatexException(f"Could not generate pdf file: {process.stderr}")
+        except subprocess.CalledProcessError as e:
+            raise LatexException(f"Could not generate pdf file: {e}") from e
 
     def get_table(self, symbol_type) -> str:
         table = [TABLE_HEADER]
@@ -604,10 +617,11 @@ class LatexConverter:
                 if isinstance(symbol, syms.Variable) and self.model._limited_variables:
                     for elem in self.model._limited_variables:
                         if elem.name == symbol.name:
-                            domain_str = utils._get_domain_str(elem.domain)[1:-1]
+                            domain_str = utils._get_domain_str(elem.domain, latex=True)[
+                                1:-1
+                            ]
 
-                row = f"{summary['name']} & {domain_str} & {summary['description']}\\\\"
-                row = row.replace("_", "\\_")
+                row = f"{symbol._latex_name} & {domain_str} & {summary['description']}\\\\"
                 table.append(row)
 
         table.append(TABLE_FOOTER)
@@ -615,16 +629,16 @@ class LatexConverter:
         return "\n".join(table)
 
     def get_definitions(self) -> str:
-        definitions = []
+        definitions: list[str] = []
         for equation in self.model.equations:
             if equation.name in self.model._autogen_symbols:
                 continue
 
-            domain_str = ",".join([elem.name for elem in equation.domain])
-            header = "\\subsubsection*{$" + equation.name.replace("_", "\\_")
+            domain_str = ",".join([elem.latexRepr() for elem in equation.domain])
+            header = "\\subsubsection*{" + equation._latex_name
             if domain_str:
-                header += f"_{{{domain_str}}}"
-            header += "$}\n"
+                header += f"$_{{{domain_str}}}$"
+            header += "}\n"
 
             footer = "\n\\vspace{5pt}\n\\hrule"
             latex_repr = f"{header}{equation.latexRepr()}{footer}"
@@ -633,28 +647,41 @@ class LatexConverter:
         return "\n".join(definitions)
 
     def get_constraints(self) -> str:
-        constraints = ["\\bigskip"]
+        constraints = [r"\begin{flalign*}"]
         for name in self.symbols:
             symbol = self.container[name]
             if not isinstance(symbol, syms.Variable):
                 continue
 
-            constraint = "$" + symbol.latexRepr()
+            constraint = "&" + symbol.latexRepr()
             if symbol.type == "binary":
-                constraint += (
-                    "\\in "
-                    + r"\{0,1\}"
-                    + " ~ \\forall "
-                    + ",".join(symbol.domain_names)
-                )
+                constraint += "\\in " + r"\{0,1\}"
+                if symbol.domain:
+                    constraint += (
+                        " ~ \\forall "
+                        + utils._get_domain_str(symbol.domain, latex=True)[1:-1]
+                    )
             elif symbol.type == "integer":
-                constraint += "\\in \\mathbb{Z}_{+} \\forall " + ",".join(
-                    symbol.domain_names
-                )
+                constraint += "\\in \\mathbb{Z}_{+}"
+                if symbol.domain:
+                    constraint += (
+                        " ~ \\forall "
+                        + utils._get_domain_str(symbol.domain, latex=True)[1:-1]
+                    )
             elif symbol.type == "positive":
-                constraint += "\\geq 0 ~ \\forall " + ",".join(symbol.domain_names)
+                constraint += "\\geq 0"
+                if symbol.domain:
+                    constraint += (
+                        " ~ \\forall "
+                        + utils._get_domain_str(symbol.domain, latex=True)[1:-1]
+                    )
             elif symbol.type == "negative":
-                constraint += "\\leq 0 ~ \\forall " + ",".join(symbol.domain_names)
+                constraint += "\\leq 0"
+                if symbol.domain:
+                    constraint += (
+                        " ~ \\forall "
+                        + utils._get_domain_str(symbol.domain, latex=True)[1:-1]
+                    )
             elif symbol.type == "sos1":
                 constraint += "SOS1"
             elif symbol.type == "sos2":
@@ -666,24 +693,28 @@ class LatexConverter:
             else:
                 continue
 
-            constraint += "\\\\$"
+            constraint += "&\\\\"
             constraints.append(constraint)
 
+        constraints.append(r"\end{flalign*}")
         return "\n".join(constraints)
 
     def get_header(self) -> str:
-        header = """\\documentclass[11pt]{article}
-\\usepackage{geometry}
-\\usepackage[american]{babel}
-\\usepackage{amsmath}
-\\usepackage{amssymb}
-\\usepackage[hidelinks]{hyperref}
-\\usepackage{tabularx}
-\\usepackage{ltablex}
-\\keepXColumns
-
-\\begin{document}
-\\section*{Symbols}
+        header = r"""\documentclass[11pt]{article}
+\usepackage{geometry}
+\usepackage[american]{babel}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{fontspec}
+\setmainfont{CMU Serif} % 1. Sets a font that knows Greek in text mode
+\usepackage{unicode-math} % 2. Allows Greek keys to work in math mode
+\usepackage[hidelinks]{hyperref}
+\usepackage{tabularx}
+\usepackage{ltablex}
+\keepXColumns
+
+\begin{document}
+\section*{Symbols}
 
 """
         return header

{gamspy-1.18.1 → gamspy-1.18.3}/src/gamspy/_extrinsic.py

@@ -120,7 +120,23 @@ class ExtrinsicFunction(operable.Operable):
         -------
         str
         """
-        return self.gamsRepr()
+        representation = self.name.replace("_", r"\_")
+
+        if self.args:
+            arg_strs = []
+            for arg in self.args:
+                arg_str = (
+                    str(arg).replace("_", r"\_")
+                    if isinstance(arg, (int, float, str))
+                    else arg.latexRepr()
+                )
+                arg_strs.append(arg_str)
+
+            args = ",".join(arg_strs)
+
+            representation = f"{representation}({args})"
+
+        return representation
 
 
 class ExtrinsicLibrary: