Include the GAMS version of the transport tutorial

.github/workflows/pytest.yaml

@@ -93,12 +93,27 @@ jobs:
           path: .venv
           key: venv-${{ runner.os }}-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/poetry.lock') }}
 
+      - name: Load cached gams install
+        id: cached-gams
+        uses: actions/cache@v4
+        with:
+          path: gams
+          key: gams-${{ runner.os }}
+          restore-keys: gams-${{ runner.os }}
+
       #------------------------------------------------
       #  install dependencies if cache does not exist
       #------------------------------------------------
+      - name: Install gams
+        if: steps.cached-gams.outputs.cache-hit != 'true'
+        uses: iiasa/actions/setup-gams@main
+        with:
+          version: 45.7.0
+          license: ${{ secrets.GAMS_LICENSE }}
+
       - name: Install dependencies
         if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true'
-        run: poetry install --no-interaction --no-root --with dev,server
+        run: poetry install --no-interaction --no-root --with dev,server,tutorial
 
       - name: Install PyArrow
         if: ${{ matrix.with-pyarrow }}
@@ -165,7 +180,7 @@ jobs:
       #------------------------------------------------
       - name: Install dependencies
         if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true'
-        run: poetry install --no-interaction --no-root --with dev,server
+        run: poetry install --no-interaction --no-root --with dev,server,tutorial
 
       #------------------------
       #  install root project

.gitignore

@@ -42,3 +42,9 @@ requirements.txt
 # misc
 PR.md
 .DS_STORE
+
+# tutorial/gams
+tutorial/transport/*.gdx
+tutorial/transport/*.lst
+tests/tutorial/transport/*.gdx
+tests/tutorial/transport/*.lst

ixmp4/__init__.py

@@ -1,16 +1,16 @@
-# flake8: noqa
 import importlib.metadata
 
+from ixmp4.core import IndexSet as IndexSet
 from ixmp4.core import Model as Model
+from ixmp4.core import Parameter as Parameter
 from ixmp4.core import Platform as Platform
 from ixmp4.core import Region as Region
 from ixmp4.core import Run as Run
+from ixmp4.core import Scalar as Scalar
 from ixmp4.core import Scenario as Scenario
+from ixmp4.core import Table as Table
 from ixmp4.core import Unit as Unit
 from ixmp4.core import Variable as Variable
-from ixmp4.core import IndexSet as IndexSet
-from ixmp4.core import Scalar as Scalar
-from ixmp4.core import Table as Table
 from ixmp4.core.exceptions import InconsistentIamcType as InconsistentIamcType
 from ixmp4.core.exceptions import IxmpError as IxmpError
 from ixmp4.core.exceptions import NotFound as NotFound

ixmp4/core/__init__.py

@@ -1,9 +1,14 @@
 # flake8: noqa
 from .iamc.variable import Variable as Variable
 from .model import Model as Model
+from .optimization.equation import Equation as Equation
 from .optimization.indexset import IndexSet as IndexSet
+from .optimization.parameter import Parameter as Parameter
 from .optimization.scalar import Scalar as Scalar
 from .optimization.table import Table as Table
+
+# TODO Is this really the name we want to use?
+from .optimization.variable import Variable as OptimizationVariable
 from .platform import Platform as Platform
 from .region import Region as Region
 from .run import Run as Run

ixmp4/core/optimization/data.py

@@ -1,21 +1,36 @@
 from ixmp4.data.abstract import Run
 
 from ..base import BaseFacade
+from .equation import EquationRepository
 from .indexset import IndexSetRepository
+from .parameter import ParameterRepository
 from .scalar import ScalarRepository
 from .table import TableRepository
+from .variable import VariableRepository
 
 
 class OptimizationData(BaseFacade):
     """An optimization data instance, which provides access to optimization data such as
     IndexSet, Table, Variable, etc."""
 
+    equations: EquationRepository
     indexsets: IndexSetRepository
+    parameters: ParameterRepository
     scalars: ScalarRepository
     tables: TableRepository
+    variables: VariableRepository
 
     def __init__(self, *args, run: Run, **kwargs) -> None:
         super().__init__(*args, **kwargs)
+        self.equations = EquationRepository(_backend=self.backend, _run=run)
         self.indexsets = IndexSetRepository(_backend=self.backend, _run=run)
+        self.parameters = ParameterRepository(_backend=self.backend, _run=run)
         self.scalars = ScalarRepository(_backend=self.backend, _run=run)
         self.tables = TableRepository(_backend=self.backend, _run=run)
+        self.variables = VariableRepository(_backend=self.backend, _run=run)
+
+    def remove_solution(self) -> None:
+        for equation in self.equations.list():
+            equation.remove_data()
+        for variable in self.variables.list():
+            variable.remove_data()

ixmp4/core/optimization/equation.py

@@ -0,0 +1,139 @@
+from datetime import datetime
+from typing import Any, ClassVar, Iterable
+
+import pandas as pd
+
+from ixmp4.core.base import BaseFacade, BaseModelFacade
+from ixmp4.data.abstract import Docs as DocsModel
+from ixmp4.data.abstract import Equation as EquationModel
+from ixmp4.data.abstract import Run
+from ixmp4.data.abstract.optimization import Column
+
+
+class Equation(BaseModelFacade):
+    _model: EquationModel
+    NotFound: ClassVar = EquationModel.NotFound
+    NotUnique: ClassVar = EquationModel.NotUnique
+
+    @property
+    def id(self) -> int:
+        return self._model.id
+
+    @property
+    def name(self) -> str:
+        return self._model.name
+
+    @property
+    def run_id(self) -> int:
+        return self._model.run__id
+
+    @property
+    def data(self) -> dict[str, Any]:
+        return self._model.data
+
+    def add(self, data: dict[str, Any] | pd.DataFrame) -> None:
+        # TODO change to "to the Equation"
+        """Adds data to an existing Equation."""
+        self.backend.optimization.equations.add_data(
+            equation_id=self._model.id, data=data
+        )
+        self._model.data = self.backend.optimization.equations.get(
+            run_id=self._model.run__id, name=self._model.name
+        ).data
+
+    def remove_data(self) -> None:
+        """Removes data from an existing Equation."""
+        self.backend.optimization.equations.remove_data(equation_id=self._model.id)
+        self._model.data = self.backend.optimization.equations.get(
+            run_id=self._model.run__id, name=self._model.name
+        ).data
+
+    @property
+    def levels(self) -> list:
+        return self._model.data.get("levels", [])
+
+    @property
+    def marginals(self) -> list:
+        return self._model.data.get("marginals", [])
+
+    @property
+    def constrained_to_indexsets(self) -> list[str]:
+        return [column.indexset.name for column in self._model.columns]
+
+    @property
+    def columns(self) -> list[Column]:
+        return self._model.columns
+
+    @property
+    def created_at(self) -> datetime | None:
+        return self._model.created_at
+
+    @property
+    def created_by(self) -> str | None:
+        return self._model.created_by
+
+    @property
+    def docs(self):
+        try:
+            return self.backend.optimization.equations.docs.get(self.id).description
+        except DocsModel.NotFound:
+            return None
+
+    @docs.setter
+    def docs(self, description):
+        if description is None:
+            self.backend.optimization.equations.docs.delete(self.id)
+        else:
+            self.backend.optimization.equations.docs.set(self.id, description)
+
+    @docs.deleter
+    def docs(self):
+        try:
+            self.backend.optimization.equations.docs.delete(self.id)
+        # TODO: silently failing
+        except DocsModel.NotFound:
+            return None
+
+    def __str__(self) -> str:
+        return f"<Equation {self.id} name={self.name}>"
+
+
+class EquationRepository(BaseFacade):
+    _run: Run
+
+    def __init__(self, _run: Run, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._run = _run
+
+    def create(
+        self,
+        name: str,
+        constrained_to_indexsets: list[str],
+        column_names: list[str] | None = None,
+    ) -> Equation:
+        model = self.backend.optimization.equations.create(
+            name=name,
+            run_id=self._run.id,
+            constrained_to_indexsets=constrained_to_indexsets,
+            column_names=column_names,
+        )
+        return Equation(_backend=self.backend, _model=model)
+
+    def get(self, name: str) -> Equation:
+        model = self.backend.optimization.equations.get(run_id=self._run.id, name=name)
+        return Equation(_backend=self.backend, _model=model)
+
+    def list(self, name: str | None = None) -> Iterable[Equation]:
+        equations = self.backend.optimization.equations.list(
+            run_id=self._run.id, name=name
+        )
+        return [
+            Equation(
+                _backend=self.backend,
+                _model=i,
+            )
+            for i in equations
+        ]
+
+    def tabulate(self, name: str | None = None) -> pd.DataFrame:
+        return self.backend.optimization.equations.tabulate(name=name)

ixmp4/core/optimization/indexset.py

@@ -94,7 +94,9 @@ def get(self, name: str) -> IndexSet:
         return IndexSet(_backend=self.backend, _model=indexset)
 
     def list(self, name: str | None = None) -> list[IndexSet]:
-        indexsets = self.backend.optimization.indexsets.list(name=name)
+        indexsets = self.backend.optimization.indexsets.list(
+            run_id=self._run.id, name=name
+        )
         return [
             IndexSet(
                 _backend=self.backend,
@@ -104,4 +106,6 @@ def list(self, name: str | None = None) -> list[IndexSet]:
         ]
 
     def tabulate(self, name: str | None = None) -> pd.DataFrame:
-        return self.backend.optimization.indexsets.tabulate(name=name)
+        return self.backend.optimization.indexsets.tabulate(
+            run_id=self._run.id, name=name
+        )