gamspy 1.17.0__py3-none-any.whl → 1.17.2__py3-none-any.whl

gamspy/__init__.py

@@ -50,7 +50,7 @@ from gamspy._symbols import (
 
 from .version import __version__
 
-_ctx_managers: dict[tuple[int, int], Container] = dict()
+_ctx_managers: dict[tuple[int, int], Container] = {}
 _set_default_options()
 
 __all__ = [

gamspy/_algebra/expression.py

@@ -20,8 +20,6 @@ from gamspy.exceptions import ValidationError
 from gamspy.math.misc import MathOp
 
 if TYPE_CHECKING:
-    from numbers import Real
-
     import pandas as pd
 
     from gamspy import Alias, Set
@@ -150,7 +148,7 @@ def create_gams_expression(root_node: Expression) -> str:
                 s1.append(node.right)
 
     # 2. Build the GAMS expression
-    eval_stack: list[tuple[str, Real]] = []
+    eval_stack: list[tuple[str, float]] = []
     for node in reversed(post_order_nodes):
         if not isinstance(node, Expression):
             eval_stack.append((get_operand_gams_repr(node), LEAF_PRECEDENCE))
@@ -237,7 +235,7 @@ def create_latex_expression(root_node: Expression) -> str:
                 s1.append(node.right)
 
     # 2. Build the GAMS expression
-    eval_stack: list[tuple[str, Real]] = []
+    eval_stack: list[tuple[str, float]] = []
     for node in reversed(post_order_nodes):
         if not isinstance(node, Expression):
             eval_stack.append((get_operand_latex_repr(node), LEAF_PRECEDENCE))
@@ -406,8 +404,8 @@ class Expression(operable.Operable):
 
     def __getitem__(self, indices):
         indices = validation.validate_domain(self, indices)
-        left_domain = [d for d in self._left_domain]
-        right_domain = [d for d in self._right_domain]
+        left_domain = list(self._left_domain)
+        right_domain = list(self._right_domain)
         for i, s in enumerate(indices):
             for lr, pos in self._shadow_domain[i].indices:
                 if lr == "l":
@@ -638,16 +636,16 @@ class Expression(operable.Operable):
                             symbols.append(node.alias_with.name)
 
                         symbols.append(node.name)
-                    stack += node.domain
+                    stack.extend(node.domain)
                     node = None
                 elif isinstance(node, ImplicitSymbol):
                     if node.parent.name not in symbols:
                         symbols.append(node.parent.name)
-                    stack += node.domain
-                    stack += node.container[node.parent.name].domain
+                    stack.extend(node.domain)
+                    stack.extend(node.container[node.parent.name].domain)
                     node = None
                 elif isinstance(node, operation.Operation):
-                    stack += node.op_domain
+                    stack.extend(node.op_domain)
                     node = node.rhs
                 elif isinstance(node, condition.Condition):
                     stack.append(node.conditioning_on)
@@ -664,10 +662,10 @@ class Expression(operable.Operable):
                     if isinstance(node.elements[0], Expression):
                         node = node.elements[0]
                     else:
-                        stack += node.elements
+                        stack.extend(node.elements)
                         node = None
                 elif isinstance(node, ExtrinsicFunction):
-                    stack += list(node.args)
+                    stack.extend(list(node.args))
                     node = None
                 else:
                     node = getattr(node, "right", None)
@@ -692,12 +690,12 @@ class Expression(operable.Operable):
                     given_condition = node.condition
 
                     if isinstance(given_condition, Expression):
-                        symbols += given_condition._find_all_symbols()
+                        symbols.extend(given_condition._find_all_symbols())
                     elif isinstance(given_condition, ImplicitSymbol):
                         symbols.append(given_condition.parent.name)
 
                 if isinstance(node, operation.Operation):
-                    stack += node.op_domain
+                    stack.extend(node.op_domain)
                     node = node.rhs
                 else:
                     node = getattr(node, "right", None)

gamspy/_algebra/operation.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
 import gamspy._algebra.condition as condition
@@ -14,6 +13,8 @@ import gamspy.utils as utils
 from gamspy.exceptions import ValidationError
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     import pandas as pd
 
     from gamspy._algebra import Domain
@@ -70,7 +71,7 @@ class Operation(operable.Operable):
                     self.domain.append(x)
 
         self.dimension: int = validation.get_dimension(self.domain)
-        controlled_domain = [d for d in self._bare_op_domain]
+        controlled_domain = list(self._bare_op_domain)
         controlled_domain.extend(getattr(rhs, "controlled_domain", []))
         self.controlled_domain = list(set(controlled_domain))
 

gamspy/_cli/install.py

@@ -5,8 +5,7 @@ import os
 import shutil
 import subprocess
 import sys
-from collections.abc import Iterable
-from typing import Annotated
+from typing import TYPE_CHECKING, Annotated
 
 import requests
 import typer
@@ -16,6 +15,9 @@ from gamspy.exceptions import GamspyException, ValidationError
 
 from .util import add_solver_entry
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
 app = typer.Typer(
     rich_markup_mode="rich",
     short_help="To install licenses and solvers.",

gamspy/_cli/show.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from collections.abc import Callable
 from datetime import datetime, timedelta
+from typing import TYPE_CHECKING
 
 import rich
 import rich.table
@@ -10,6 +10,9 @@ import typer
 import gamspy.utils as utils
 from gamspy.exceptions import ValidationError
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 app = typer.Typer(
     rich_markup_mode="rich",
     short_help="To show your license and gamspy_base directory.",

gamspy/_cli/uninstall.py

@@ -3,8 +3,7 @@ from __future__ import annotations
 import os
 import subprocess
 import sys
-from collections.abc import Iterable
-from typing import Annotated
+from typing import TYPE_CHECKING, Annotated
 
 import typer
 
@@ -13,6 +12,9 @@ from gamspy.exceptions import GamspyException, ValidationError
 
 from .util import remove_solver_entry
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
 app = typer.Typer(
     rich_markup_mode="rich",
     short_help="To uninstall licenses and solvers.",

gamspy/_config.py

@@ -5,7 +5,7 @@ from typing import Any, Literal
 
 from gamspy.exceptions import ValidationError
 
-configuration: dict[str, Any] = dict()
+configuration: dict[str, Any] = {}
 
 
 def _set_default_options() -> None:

gamspy/_container.py

@@ -11,7 +11,6 @@ import threading
 import time
 import traceback
 import weakref
-from collections.abc import Iterable, Sequence
 from typing import TYPE_CHECKING
 
 import gams.transfer as gt
@@ -25,12 +24,12 @@ from gamspy._config import get_option
 from gamspy._extrinsic import ExtrinsicLibrary
 from gamspy._miro import MiroJSONEncoder
 from gamspy._model import Problem, Sense
-from gamspy._options import Options
 from gamspy._workspace import Workspace
 from gamspy.exceptions import FatalError, GamspyException, ValidationError
 
 if TYPE_CHECKING:
     import io
+    from collections.abc import Iterable, Sequence
     from typing import Any, Literal, TypeAlias
 
     from pandas import DataFrame
@@ -46,6 +45,8 @@ if TYPE_CHECKING:
     )
     from gamspy._algebra.expression import Expression
     from gamspy._algebra.operation import Operation
+    from gamspy._options import Options
+    from gamspy._symbols.implicits import ImplicitVariable
     from gamspy.math.matrix import Dim
 
     SymbolType: TypeAlias = Set | Alias | Parameter | Variable | Equation
@@ -267,7 +268,7 @@ class Container(gt.Container):
     ):
         self.output = output
         self._gams_string = ""
-        self.models: dict[str, Model] = dict()
+        self.models: dict[str, Model] = {}
         if IS_MIRO_INIT:
             atexit.register(self._write_miro_files)
 
@@ -339,7 +340,7 @@ class Container(gt.Container):
                     {"restart": load_from, "gdxSymbols": "all"}
                 )
                 self._synch_with_gams(gams_to_gamspy=True)
-                self._options._set_debug_options(dict())
+                self._options._set_debug_options({})
                 self._clean_modified_symbols()
                 self._unsaved_statements = []
                 self._is_restarted = True
@@ -679,7 +680,8 @@ class Container(gt.Container):
             strings.append("$offDotL")
         elif assume_suffix == 2:
             strings.append("$offDotScale")
-        strings += ["$offUNDF", "$offMulti"]
+
+        strings.extend(["$offUNDF", "$offMulti"])
 
         if not IS_MIRO_INIT and MIRO_GDX_OUT:
             if len(self._miro_output_symbols) == 0:
@@ -1062,6 +1064,9 @@ class Container(gt.Container):
         >>> a = m.addAlias("a", i)
 
         """
+        if name is None:
+            name = self._get_symbol_name(prefix="a")
+
         return gp.Alias(self, name, alias_with)
 
     def addSet(
@@ -1119,6 +1124,9 @@ class Container(gt.Container):
         >>> i = m.addSet("i")
 
         """
+        if name is None:
+            name = self._get_symbol_name(prefix="s")
+
         return gp.Set(
             self,
             name,
@@ -1187,6 +1195,9 @@ class Container(gt.Container):
         >>> a = m.addParameter("a")
 
         """
+        if name is None:
+            name = self._get_symbol_name(prefix="p")
+
         return gp.Parameter(
             self,
             name,
@@ -1250,6 +1261,9 @@ class Container(gt.Container):
         >>> v = m.addVariable("v")
 
         """
+        if name is None:
+            name = self._get_symbol_name(prefix="v")
+
         return gp.Variable(
             self,
             name,
@@ -1320,6 +1334,9 @@ class Container(gt.Container):
         >>> i = m.addEquation("i")
 
         """
+        if name is None:
+            name = self._get_symbol_name(prefix="e")
+
         return gp.Equation(
             self,
             name,
@@ -1347,7 +1364,7 @@ class Container(gt.Container):
             Variable | Sequence[Variable],
         ]
         | None = None,
-        limited_variables: Sequence[Variable] | None = None,
+        limited_variables: Sequence[ImplicitVariable] | None = None,
         external_module: str | None = None,
     ) -> Model:
         """
@@ -1370,7 +1387,7 @@ class Container(gt.Container):
             Objective variable to minimize or maximize or objective itself.
         matches : dict[Equation | Sequence[Equation], Variable | Sequence[Variable]], optional
             Equation - Variable matches for MCP models.
-        limited_variables : Sequence, optional
+        limited_variables : Sequence[ImplicitVariable], optional
             Allows limiting the domain of variables used in a model.
         external_module: str, optional
             The name of the external module in which the external equations are implemented
@@ -1387,6 +1404,9 @@ class Container(gt.Container):
         >>> model = m.addModel("my_model", "LP", [e])
 
         """
+        if name is None:
+            name = self._get_symbol_name(prefix="m")
+
         return gp.Model(
             self,
             name,

gamspy/_convert.py

@@ -4,7 +4,7 @@ import logging
 import os
 import subprocess
 from collections.abc import Sequence
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import gamspy._symbols as syms
 import gamspy.utils as utils
@@ -12,6 +12,7 @@ from gamspy._options import EXECUTION_OPTIONS, MODEL_ATTR_OPTION_MAP, Options
 from gamspy.exceptions import LatexException, ValidationError
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from typing import TypeAlias
 
     from gamspy import (
@@ -80,11 +81,11 @@ option js<js2; jd(js) = yes;
 jc(j) = yes;
 jc(jd) = no;
 
-xb.lo(jb)       =xc.lo(jb);  xb.up(jb)       =xc.up(jb);  xb.prior(jb)       =xc.scale(jb); 
-xi.lo(ji)       =xc.lo(ji);  xi.up(ji)       =xc.up(ji);  xi.prior(ji)       =xc.scale(ji); 
-xsc.lo(jsc)     =xc.lo(jsc); xsc.up(jsc)     =xc.up(jsc); xsc.prior(jsc)     =xc.scale(jsc); 
-xsi.lo(jsi)     =xc.lo(jsi); xsi.up(jsi)     =xc.up(jsi); xsi.prior(jsi)     =xc.scale(jsi); 
-xs1.lo(js1(s,j))=xc.lo(j);   xs1.up(js1(s,j))=xc.up(j);   xs1.prior(js1(s,j))=xc.scale(j); 
+xb.lo(jb)       =xc.lo(jb);  xb.up(jb)       =xc.up(jb);  xb.prior(jb)       =xc.scale(jb);
+xi.lo(ji)       =xc.lo(ji);  xi.up(ji)       =xc.up(ji);  xi.prior(ji)       =xc.scale(ji);
+xsc.lo(jsc)     =xc.lo(jsc); xsc.up(jsc)     =xc.up(jsc); xsc.prior(jsc)     =xc.scale(jsc);
+xsi.lo(jsi)     =xc.lo(jsi); xsi.up(jsi)     =xc.up(jsi); xsi.prior(jsi)     =xc.scale(jsi);
+xs1.lo(js1(s,j))=xc.lo(j);   xs1.up(js1(s,j))=xc.up(j);   xs1.prior(js1(s,j))=xc.scale(j);
 xs2.lo(js2(s,j))=xc.lo(j);   xs2.up(js2(s,j))=xc.up(j);   xs2.prior(js2(s,j))=xc.scale(j);
 
 option ij<A;
@@ -300,7 +301,7 @@ jac.solve(output=sys.stdout, options=options)
 
 
 def get_convert_solver_options(
-    path: str,
+    path: Path,
     file_format: FileFormat | Sequence[FileFormat],
     options: ConvertOptions | None,
 ) -> dict[str, str]:
@@ -319,7 +320,7 @@ def get_convert_solver_options(
     if any(not isinstance(format, FileFormat) for format in file_format):
         raise ValidationError("`file_format` must be a FileFormat enum.")
 
-    solver_options = {}
+    solver_options: dict[str, Any] = {}
     for format in file_format:
         name, value = format.name, format.value
         if name in FORMAT_RENAME_MAP:
@@ -335,13 +336,13 @@ def get_convert_solver_options(
                     "$if not set jacfile $abort Please set --jacfile=<filename>.gdx"
                 )
 
-            with open(os.path.join(path, value), "w") as file:
+            with open(path / value, "w") as file:
                 file.write(jacobian_gms)
         elif format == FileFormat.GAMSPyJacobian:
-            with open(os.path.join(path, value), "w") as file:
+            with open(path / value, "w") as file:
                 file.write(GAMSPY_JACOBIAN)
         else:
-            solver_options[name] = os.path.join(path, value)
+            solver_options[name] = str((path / value).resolve())
 
     if options is not None:
         extra_options = options.model_dump(exclude_none=True)
@@ -375,7 +376,7 @@ class GamsConverter:
     def __init__(
         self,
         model: Model,
-        path: str,
+        path: Path,
         options: Options | None,
         dump_gams_state: bool,
     ) -> None:
@@ -385,9 +386,9 @@ class GamsConverter:
         self.path = path
         self.options = options
         self.dump_gams_state = dump_gams_state
-        self.gdx_path = os.path.join(path, model.name + "_data.gdx")
-        self.gms_path = os.path.join(path, model.name + ".gms")
-        self.g00_path = os.path.join(path, model.name + ".g00")
+        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())
 
     def get_definitions(self) -> list[str]:
         definitions = []
@@ -441,7 +442,7 @@ class GamsConverter:
             )
 
         # 2. Load the data from gdx
-        load_str = f"$onMultiR\n$gdxLoadAll {os.path.abspath(self.gdx_path)}\n$offMulti"
+        load_str = f'$onMultiR\n$gdxLoadAll "{self.gdx_path}"\n$offMulti'
 
         # 3. Definitions
         definitions = self.get_definitions()
@@ -493,7 +494,7 @@ TABLE_FOOTER = "\\hline\n\\end{tabularx}"
 
 
 class LatexConverter:
-    def __init__(self, model: Model, path: str) -> None:
+    def __init__(self, model: Model, path: Path) -> None:
         os.makedirs(path, exist_ok=True)
         self.model = model
         self.container = model.container

gamspy/_database.py

@@ -193,7 +193,7 @@ class Database:
     """Communicates data between Python and GAMS"""
 
     def __init__(self, ws: Workspace):
-        self.symbols: dict = dict()
+        self.symbols: dict = {}
         self.workspace = ws
         self.gmd = new_gmdHandle_tp()
 

gamspy/_miro.py

@@ -303,7 +303,7 @@ class MiroJSONEncoder:
 
         symbol_dicts = self.prepare_symbols(non_scalars)
 
-        non_scalars = [name for name in non_scalars]
+        non_scalars = list(non_scalars)
 
         keys = non_scalars
         values = symbol_dicts