Include the linopy version of the transport tutorial

.github/workflows/pytest.yaml

@@ -107,7 +107,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
 
       - name: Install PyArrow
         if: ${{ matrix.with-pyarrow }}
@@ -174,7 +174,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

ixmp4/core/__init__.py

@@ -3,9 +3,9 @@
 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
-from .optimization.parameter import Parameter as Parameter
 
 # TODO Is this really the name we want to use?
 from .optimization.variable import Variable as OptimizationVariable

ixmp4/core/optimization/data.py

@@ -28,3 +28,9 @@ def __init__(self, *args, run: Run, **kwargs) -> None:
         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

@@ -32,7 +32,7 @@ def data(self) -> dict[str, Any]:
         return self._model.data
 
     def add(self, data: dict[str, Any] | pd.DataFrame) -> None:
-        """Adds data to an existing Equation."""
+        """Adds data to the Equation."""
         self.backend.optimization.equations.add_data(
             equation_id=self._model.id, data=data
         )
@@ -41,7 +41,7 @@ def add(self, data: dict[str, Any] | pd.DataFrame) -> None:
         ).data
 
     def remove_data(self) -> None:
-        """Removes data from an existing Equation."""
+        """Removes all data from the 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

ixmp4/core/optimization/parameter.py

@@ -32,7 +32,7 @@ def data(self) -> dict[str, Any]:
         return self._model.data
 
     def add(self, data: dict[str, Any] | pd.DataFrame) -> None:
-        """Adds data to an existing Parameter."""
+        """Adds data to the Parameter."""
         self.backend.optimization.parameters.add_data(
             parameter_id=self._model.id, data=data
         )

ixmp4/core/optimization/scalar.py

@@ -44,9 +44,7 @@ def unit(self):
 
     @unit.setter
     def unit(self, unit: str | Unit):
-        if isinstance(unit, Unit):
-            unit = unit
-        else:
+        if not isinstance(unit, Unit):
             unit_model = self.backend.units.get(unit)
             unit = Unit(_backend=self.backend, _model=unit_model)
         self._model = self.backend.optimization.scalars.update(

ixmp4/core/optimization/table.py

@@ -32,7 +32,7 @@ def data(self) -> dict[str, Any]:
         return self._model.data
 
     def add(self, data: dict[str, Any] | pd.DataFrame) -> None:
-        """Adds data to an existing Table."""
+        """Adds data to an the Table."""
         self.backend.optimization.tables.add_data(table_id=self._model.id, data=data)
         self._model.data = self.backend.optimization.tables.get(
             run_id=self._model.run__id, name=self._model.name

ixmp4/core/optimization/variable.py

@@ -32,7 +32,7 @@ def data(self) -> dict[str, Any]:
         return self._model.data
 
     def add(self, data: dict[str, Any] | pd.DataFrame) -> None:
-        """Adds data to an existing Variable."""
+        """Adds data to the Variable."""
         self.backend.optimization.variables.add_data(
             variable_id=self._model.id, data=data
         )
@@ -41,7 +41,7 @@ def add(self, data: dict[str, Any] | pd.DataFrame) -> None:
         ).data
 
     def remove_data(self) -> None:
-        """Removes data from an existing Variable."""
+        """Removes all data from the Variable."""
         self.backend.optimization.variables.remove_data(variable_id=self._model.id)
         self._model.data = self.backend.optimization.variables.get(
             run_id=self._model.run__id, name=self._model.name

ixmp4/core/run.py

@@ -95,6 +95,68 @@ def tabulate(self, default_only: bool = True, **kwargs) -> pd.DataFrame:
         runs["scenario"] = runs["scenario__id"].map(self.backend.scenarios.map())
         return runs[["id", "model", "scenario", "version", "is_default"]]
 
+    def clone(
+        self,
+        run_id: int,
+        model: str | None = None,
+        scenario: str | None = None,
+        keep_solution: bool = True,
+    ) -> Run:
+        base_run = Run(
+            _backend=self.backend, _model=self.backend.runs.get_by_id(run_id)
+        )
+        run = Run(
+            _backend=self.backend,
+            _model=self.backend.runs.create(
+                model if model else base_run.model.name,
+                scenario if scenario else base_run.scenario.name,
+            ),
+        )
+        datapoints = base_run.iamc.tabulate()
+        if not datapoints.empty:
+            run.iamc.add(df=datapoints)
+        for scalar in base_run.optimization.scalars.list():
+            run.optimization.scalars.create(
+                name=scalar.name,
+                value=scalar.value,
+                unit=self.backend.units.get(scalar.unit.name).name,
+            )
+        for indexset in base_run.optimization.indexsets.list():
+            run.optimization.indexsets.create(name=indexset.name).add(
+                elements=indexset.elements
+            )
+        for table in base_run.optimization.tables.list():
+            run.optimization.tables.create(
+                name=table.name,
+                constrained_to_indexsets=table.constrained_to_indexsets,
+                column_names=[column.name for column in table.columns],
+            ).add(data=table.data)
+        for parameter in base_run.optimization.parameters.list():
+            run.optimization.parameters.create(
+                name=parameter.name,
+                constrained_to_indexsets=parameter.constrained_to_indexsets,
+                column_names=[column.name for column in parameter.columns],
+            ).add(data=parameter.data)
+        for equation in base_run.optimization.equations.list():
+            cloned_equation = run.optimization.equations.create(
+                name=equation.name,
+                constrained_to_indexsets=equation.constrained_to_indexsets,
+                column_names=[column.name for column in equation.columns],
+            )
+            if keep_solution:
+                cloned_equation.add(data=equation.data)
+        for variable in base_run.optimization.variables.list():
+            cloned_variable = run.optimization.variables.create(
+                name=variable.name,
+                constrained_to_indexsets=variable.constrained_to_indexsets,
+                column_names=[column.name for column in variable.columns]
+                if variable.columns
+                else None,
+            )
+            if keep_solution:
+                cloned_variable.add(data=variable.data)
+        return run
+
 
 class RunMetaFacade(BaseFacade, UserDict):
     run: RunModel

ixmp4/data/abstract/run.py

@@ -143,6 +143,26 @@ def get_default_version(
         """
         ...
 
+    def get_by_id(self, id: int) -> Run:
+        """Retrieves a Run by its id.
+
+        Parameters
+        ----------
+        id : int
+            Unique integer id.
+
+        Raises
+        ------
+        :class:`ixmp4.data.abstract.Run.NotFound`.
+            If the Run with `id` does not exist.
+
+        Returns
+        -------
+        :class:`ixmp4.data.abstract.Run`:
+            The retrieved Run.
+        """
+        ...
+
     def list(
         self,
         *,

ixmp4/data/api/run.py

@@ -50,6 +50,10 @@ def get(self, model_name: str, scenario_name: str, version: int) -> Run:
             is_default=None,
         )
 
+    def get_by_id(self, id: int) -> Run:
+        res = self._get_by_id(id)
+        return Run(**res)
+
     def enumerate(self, **kwargs) -> list[Run] | pd.DataFrame:
         return super().enumerate(**kwargs)
 

ixmp4/data/db/optimization/equation/model.py

@@ -31,11 +31,12 @@ def validate_data(self, key, data: dict[str, Any]):
         data_to_validate = copy.deepcopy(data)
         del data_to_validate["levels"]
         del data_to_validate["marginals"]
-        _ = utils.validate_data(
-            host=self,
-            data=data_to_validate,
-            columns=self.columns,
-        )
+        if data_to_validate != {}:
+            _ = utils.validate_data(
+                host=self,
+                data=data_to_validate,
+                columns=self.columns,
+            )
         return data
 
     __table_args__ = (db.UniqueConstraint("name", "run__id"),)

ixmp4/data/db/optimization/indexset/repository.py

@@ -77,5 +77,4 @@ def add_elements(
         else:
             indexset.elements = indexset.elements + elements
 
-        self.session.add(indexset)
         self.session.commit()

ixmp4/data/db/optimization/table/repository.py

@@ -159,5 +159,4 @@ def add_data(self, table_id: int, data: dict[str, Any] | pd.DataFrame) -> None:
             orient="list"
         )
 
-        self.session.add(table)
         self.session.commit()

ixmp4/data/db/optimization/utils.py

@@ -10,13 +10,10 @@
 
 def collect_indexsets_to_check(
     columns: list["Column"],
-) -> dict[str, Any]:
+) -> dict[str, list[float | int | str]]:
     """Creates a {key:value} dict from linked Column.names and their
     IndexSet.elements."""
-    collection: dict[str, Any] = {}
-    for column in columns:
-        collection[column.name] = column.indexset.elements
-    return collection
+    return {column.name: column.indexset.elements for column in columns}
 
 
 def validate_data(host: base.BaseModel, data: dict[str, Any], columns: list["Column"]):

ixmp4/data/db/optimization/variable/model.py

@@ -32,11 +32,12 @@ def validate_data(self, key, data: dict[str, Any]):
         data_to_validate = copy.deepcopy(data)
         del data_to_validate["levels"]
         del data_to_validate["marginals"]
-        _ = utils.validate_data(
-            host=self,
-            data=data_to_validate,
-            columns=self.columns,
-        )
+        if data_to_validate != {}:
+            _ = utils.validate_data(
+                host=self,
+                data=data_to_validate,
+                columns=self.columns,
+            )
         return data
 
     __table_args__ = (db.UniqueConstraint("name", "run__id"),)

ixmp4/data/db/optimization/variable/repository.py

@@ -180,13 +180,18 @@ def add_data(self, variable_id: int, data: dict[str, Any] | pd.DataFrame) -> Non
                 f"{', '.join(missing_columns)}!"
             )
 
+        # TODO Somehow, this got to main without the if index_list checks
+        # -> Do we need/have a test for add_data() to a scalar variable?
         index_list = [column.name for column in variable.columns]
         existing_data = pd.DataFrame(variable.data)
-        if not existing_data.empty:
-            existing_data.set_index(index_list, inplace=True)
-        variable.data = (
-            data.set_index(index_list).combine_first(existing_data).reset_index()
-        ).to_dict(orient="list")
+        if index_list:
+            data = data.set_index(index_list)
+            if not existing_data.empty:
+                existing_data.set_index(index_list, inplace=True)
+        data = data.combine_first(existing_data)
+        if index_list:
+            data = data.reset_index()
+        variable.data = data.to_dict(orient="list")
 
         self.session.commit()