zen-garden 2.7.9__tar.gz → 2.7.10__tar.gz

{zen_garden-2.7.9 → zen_garden-2.7.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zen_garden
-Version: 2.7.9
+Version: 2.7.10
 Summary: ZEN-garden is an optimization model of energy systems and value chains.
 Author: Alissa Ganter, Johannes Burger, Francesco De Marco, Lukas Kunz, Lukas Schmidt-Engelbertz, Paolo Gabrielli, Giovanni Sansavini
 Author-email: Jacob Mannhardt <zen-garden@ethz.ch>

{zen_garden-2.7.9 → zen_garden-2.7.10}/pyproject.toml

@@ -15,7 +15,7 @@ authors = [
   {name = "Giovanni Sansavini"},
   ]
 # do not change version manually! Done by bump2version
-version = "2.7.9"
+version = "2.7.10"
 requires-python= ">=3.11,<3.14"
 description="ZEN-garden is an optimization model of energy systems and value chains."
 readme = "README.md"

{zen_garden-2.7.9 → zen_garden-2.7.10}/zen_garden/__main__.py

@@ -10,6 +10,7 @@ import os
 import zen_garden.default_config as default_config
 import json
 from zen_garden.utils import copy_dataset_example
+from pathlib import Path
 
 def run_module(args=None, config = "./config.py", dataset = None, 
                folder_output = None, job_index = None, job_index_var = "SLURM_ARRAY_TASK_ID",
@@ -32,7 +33,7 @@ def run_module(args=None, config = "./config.py", dataset = None,
     parser.add_argument("--config", required=False, type=str, default=config, help="Path to the config file used to run the pipeline (e.g., `./config.json`). Alternatively, if the config file is located in the current working directory, then the file name is alone is also acceptable (e.g. `config.json`).")
     parser.add_argument("--dataset", required=False, type=str, default=dataset, help="Path to the dataset (e.g. `./<dataset_name>`). Alternatively, if the dataset is located in the current working directory, then the folder name alone is also acceptable (e.g. `<dataset_name>`). IMPORTANT: This will overwrite the config.analysis.dataset attribute of the config file!")
     parser.add_argument("--folder_output", required=False, type=str, default=folder_output, help="Path to the folder where results of the run are stored. IMPORTANT: This will overwrite the "
-                                                                                        "config.analysis.folder_output attribute of the config file!")
+                                                                                        "config.analysis.folder_output attribute and the config.solver.solver_dir attribute of the config file!")
     parser.add_argument("--job_index", required=False, type=str, default=job_index, help="A comma separated list (no spaces) of indices of the scenarios to run, if None, all scenarios are run in sequence")
     parser.add_argument("--job_index_var", required=False, type=str, default=job_index_var, help="Try to read out the job index from the environment variable specified here. "
                                                                                                          "If both --job_index and --job_index_var are specified, --job_index will be used.")
@@ -48,18 +49,15 @@ def run_module(args=None, config = "./config.py", dataset = None,
     if not os.path.exists(args.config):
         args.config = args.config.replace(".py", ".json")
 
-    # change working directory to the directory of the config file
-
-    config_path, config_file = os.path.split(os.path.abspath(args.config))
-    os.chdir(config_path)
     ### import the config
+    config_path, config_file = os.path.split(os.path.abspath(args.config))
     if config_file.endswith(".py"):
-        spec = importlib.util.spec_from_file_location("module", config_file)
+        spec = importlib.util.spec_from_file_location("module", Path(config_path) / config_file)
         module = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(module)
         config = module.config
     else:
-        with open(args.config, "r") as f:
+        with open(Path(config_path) / config_file, "r") as f:
             config = default_config.Config(**json.load(f))
 
     ### get the job index

{zen_garden-2.7.9 → zen_garden-2.7.10}/zen_garden/_internal.py

@@ -37,7 +37,8 @@ def main(config, dataset_path=None, job_index=None, folder_output_path=None):
         # logging.info(f"Overwriting dataset to: {dataset_path}")
         config.analysis.dataset = dataset_path
     if folder_output_path is not None:
-        config.analysis.folder_output = folder_output_path
+        config.analysis.folder_output = os.path.abspath(folder_output_path)
+        config.solver.solver_dir = os.path.abspath(folder_output_path)
     logging.info(f"Optimizing for dataset {config.analysis.dataset}")
     # get the abs path to avoid working dir stuff
     config.analysis.dataset = os.path.abspath(config.analysis.dataset)

{zen_garden-2.7.9 → zen_garden-2.7.10}/zen_garden/postprocess/postprocess.py

@@ -434,8 +434,9 @@ class Postprocess:
             fname = self.name_dir.joinpath('analysis')
         # remove cwd path part to avoid saving the absolute path
         if os.path.isabs(self.analysis.dataset):
-            self.analysis.dataset = os.path.split(Path(self.analysis.dataset))[-1]
-            self.analysis.folder_output = os.path.split(Path(self.analysis.folder_output))[-1]
+            cwd = os.getcwd()
+            self.analysis.dataset = os.path.relpath(self.analysis.dataset,cwd)
+            self.analysis.folder_output = os.path.relpath(self.analysis.folder_output, cwd)
         self.write_file(fname, self.analysis, format="json")
 
     def save_solver(self):
@@ -447,6 +448,12 @@ class Postprocess:
             fname = self.name_dir.parent.joinpath('solver')
         else:
             fname = self.name_dir.joinpath('solver')
+        
+        # remove cwd path part to avoid saving the absolute path
+        if os.path.isabs(self.solver.solver_dir):
+            cwd = os.getcwd()
+            self.solver.solver_dir = os.path.relpath(self.solver.solver_dir,cwd)
+        # save    
         self.write_file(fname, self.solver, format="json")
 
     def save_scenarios(self):
@@ -454,8 +461,8 @@ class Postprocess:
         Saves the scenario dict as json
         """
         # only save the scenarios at the highest level
-        root_path = Path(self.analysis.folder_output).joinpath(self.model_name)
-        fname = root_path.joinpath('scenarios')
+        root_dir = Path(self.analysis.folder_output).joinpath(self.model_name)
+        fname = root_dir.joinpath('scenarios')
         self.write_file(fname, self.scenarios, format="json")
 
     def save_unit_definitions(self):

{zen_garden-2.7.9 → zen_garden-2.7.10}/zen_garden/postprocess/results/results.py

@@ -569,10 +569,28 @@ class Results:
 
     def get_system(self, scenario_name: Optional[str] = None) -> System:
         """
-        Extracts the System config of a given Scenario. If no scenario is given, a random one is taken.
+        Extract system configurations from a scenario.
+
+        Extracts system configurations from the results of a scenario. This 
+        ensures the tractability of model configurations. System configurations
+        are those specified in the ``system.json`` file of a given model.
+
+        Args:
+            scenario_name (str, optional): The name of the scenario for which
+                to extract the system configuration. If no value is given, then
+                the first scenario is used. Default value: ``None``.
+
+        Returns:
+            System: System configuration.
+
+        Examples:
+            Basic usage example:
+
+            >>> from zen_garden.postprocess.results.results import Results
+            >>> r = Results(path='<result_folder>')
+            >>> r.get_system() # system configurations of first scenario
+            >>> r.get_system('scenario_name') # system configuration of "scenario_name"
 
-        :param scenario_name: Name of the scenario
-        :return: The corresponding System config
         """
         if scenario_name is None:
             scenario_name = next(iter(self.solution_loader.scenarios.keys()))
@@ -580,10 +598,29 @@ class Results:
 
     def get_analysis(self, scenario_name: Optional[str] = None) -> Analysis:
         """
-        Extracts the Analysis config of a given Scenario. If no scenario is given, a random one is taken.
+        Extract analysis configurations from a scenario.
+
+        Extracts analysis configurations from the results of a scenario. This 
+        ensures the tractability of model configurations. Analysis configurations 
+        are those specified under the ``analysis`` object in the ``config.json``
+        file.
+
+        Args:
+            scenario_name (str, optional): The name of the scenario for which
+                to extract the system configuration. If no value is given, then
+                the first scenario is used. Default value: ``None``.
+
+        Returns:
+            Analysis: Analysis configuration.
+
+        Examples:
+            Basic usage example:
+
+            >>> from zen_garden.postprocess.results.results import Results
+            >>> r = Results(path='<result_folder>')
+            >>> r.get_analysis() # analysis configurations of first scenario
+            >>> r.get_analysis('scenario_name') # analysis configuration of "scenario_name"
 
-        :param scenario_name: Name of the scenario
-        :return: The corresponding Analysis config
         """
         if scenario_name is None:
             scenario_name = next(iter(self.solution_loader.scenarios.keys()))
@@ -591,10 +628,29 @@ class Results:
 
     def get_solver(self, scenario_name: Optional[str] = None) -> Solver:
         """
-        Extracts the Solver config of a given Scenario. If no scenario is given, a random one is taken.
+        Extract solver configurations from a scenario.
+
+        Extracts solver configurations from the results of a scenario. This 
+        ensures the tractability of model configurations. Solver configurations 
+        are those specified under the ``solver`` object in the ``config.json``
+        file.
+
+        Args:
+            scenario_name (str, optional): The name of the scenario for which
+                to extract the system configuration. If no value is given, then
+                the first scenario is used. Default value: ``None``.
+
+        Returns:
+            Solver: Solver configuration.
+
+        Examples:
+            Basic usage example:
+
+            >>> from zen_garden.postprocess.results.results import Results
+            >>> r = Results(path='<result_folder>')
+            >>> r.get_solver() # solver configurations of first scenario
+            >>> r.get_solver('scenario_name') # solver configuration of "scenario_name"
 
-        :param scenario_name: Name of the scenario
-        :return: The corresponding Solver config
         """
         if scenario_name is None:
             scenario_name = next(iter(self.solution_loader.scenarios.keys()))