zen-garden 2.7.18__tar.gz → 2.7.20__tar.gz

{zen_garden-2.7.18 → zen_garden-2.7.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zen_garden
-Version: 2.7.18
+Version: 2.7.20
 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, Christoph Funke, Paolo Gabrielli, Giovanni Sansavini
 Author-email: Jacob Mannhardt <zen-garden@ethz.ch>

{zen_garden-2.7.18 → zen_garden-2.7.20}/pyproject.toml

@@ -16,7 +16,7 @@ authors = [
   {name = "Giovanni Sansavini"},
   ]
 # do not change version manually! Done by bump2version
-version = "2.7.18"
+version = "2.7.20"
 requires-python= ">=3.11,<3.14"
 description="ZEN-garden is an optimization model of energy systems and value chains."
 readme = "README.md"
@@ -78,5 +78,6 @@ Zenodo = "https://zenodo.org/api/records/13385110"
 addopts = "-n auto"
 
 [project.scripts]
-zen-garden = "zen_garden.__main__:run_module"
-zen-visualization = "zen_garden.visualization:parse_arguments_and_run"
+zen-garden = "zen_garden.cli.zen_garden:cli_zen_garden"
+zen-visualization = "zen_garden.cli.zen_visualization:cli_zen_visualization"
+zen-example = "zen_garden.cli.zen_example:cli_zen_example"

{zen_garden-2.7.18 → zen_garden-2.7.20}/zen_garden/__init__.py

@@ -2,9 +2,14 @@ from . import model
 from . import postprocess
 from . import preprocess
 from .utils import get_inheritors
-
 from .model.element import Element
 from .optimization_setup import OptimizationSetup
+from .runner import run
+from .postprocess.results.results import Results
+from .utils import download_example_dataset
+
+__all__ = ["run", "Results", "download_example_dataset"]
+
 
 # set the element classes of the EnergySystem class
 inheritors = get_inheritors(Element)

zen_garden-2.7.20/zen_garden/__main__.py

@@ -0,0 +1,71 @@
+"""
+Runs the main function of ZEN-Garden.
+Compilation  of the optimization problem.
+"""
+from .runner import run
+from .cli.zen_garden import cli_zen_garden
+import warnings
+
+def run_module(config = "./config.py", dataset = None, 
+               folder_output = None, job_index = None):
+    """
+    Deprecated wrapper for ``zen_garden.runner.run()``.
+
+    This function mirrors the behavior of
+    ``zen_garden.runner.run()`` and exists solely for backward
+    compatibility with older versions of ZEN_garden, where
+    ``zen_garden.__main__.run_module()`` served as the primary entry point.
+
+    This function is deprecated and will be removed in ZEN-garden v3.0.0.
+    Users should migrate to ``zen_garden.runner.run()``.
+
+    Args:
+        config (str): Path to the configuration file (e.g. ``config.json``).
+            If the file is located in the current working directory, the
+            filename alone may be specified. Defaults to ``"./config.py"``.
+        dataset (str): Path to the folder containing the input dataset
+            (e.g. ``"./1_base_case"``). If located in the current working
+            directory, the folder name alone may be used. Defaults to the
+            ``dataset`` value specified in the configuration file.
+        folder_output (str): Path to the folder where outputs will be saved.
+            Defaults to ``"./outputs"``.
+        job_index (list[int] | None): Indices of jobs (scenarios) to run.
+            For example, ``job_index=[1]`` runs only the first scenario.
+            Defaults to ``None`` (run all jobs).
+
+    Raises:
+        DeprecationWarning: This function will be removed in ZEN-garden v3.0.0.
+
+    Returns:
+        OptimizationSetup: The fully set up and solved optimization problem.
+
+    See Also:
+        zen_garden.runner.run: Replacement function.
+
+    Examples:
+        >>> from zen_garden import run, copy_example_dataset
+        >>> download_example_dataset("1_base_case")
+        >>> run("1_base_case")
+    """
+
+
+    # throw deprecation warning
+    warnings.warn(
+        "zen_garden.__main__.run_module() is deprecated and will be removed " \
+        "in ZEN-garden v3.0.0. Please use the new version " \
+        "zen_garden.runner.run() instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+
+    # run new function
+    return run(
+        config = config, 
+        dataset = dataset, 
+        folder_output=folder_output,
+        job_index=job_index
+        )
+
+if __name__ == "__main__":
+
+    cli_zen_garden()

zen_garden-2.7.20/zen_garden/cli/zen_example.py

@@ -0,0 +1,43 @@
+import argparse
+import sys
+from zen_garden.utils import download_example_dataset
+
+def cli_zen_example():
+    """ 
+    Entry point for the `zen-example` command-line interface.
+
+    Creates a command line interface for downloading the dataset examples. 
+    The function parses a single required argument ``--dataset`` that 
+    specifies the name of the dataset to be downloaded. It then invokes
+    the function function ``download_example_dataset`` with that argument.
+
+    The ``[project.scripts]`` section of the pyproject.toml declares that 
+    this function will be called whenever a user enters ``zen-example`` into
+    the command prompt. This function is therefore creates the ``zen-example`` 
+    command line entry point.
+
+    Examples:
+        Basic usage in a command line prompt:
+
+        >>> zen-example --dataset="1_base_case"
+
+    """
+    # parse the args
+    description = "Downloads an example dataset for ZEN-garden to the current" \
+        "working directory"
+
+    parser = argparse.ArgumentParser(
+        description=description,
+        add_help=True,
+        usage="usage: zen-example [--dataset DATASET]")
+
+    parser.add_argument(
+        "--dataset",
+        required=True,
+        type=str,
+        help="Name of the dataset to download, e.g. '1_base_case'")
+
+    args = parser.parse_args(sys.argv[1:])
+
+    # download the example
+    download_example_dataset(args.dataset)

zen_garden-2.7.20/zen_garden/cli/zen_garden.py

@@ -0,0 +1,165 @@
+import argparse
+from zen_garden.runner import run
+import os
+
+# ---------------------------------------------------------------------------
+# Command-line interface
+# ---------------------------------------------------------------------------
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the command-line argument parser for ZEN-garden.
+
+    This function defines all supported command-line options for running
+    ZEN-garden. The parser handles configuration file selection, dataset and
+    output directory overrides, and job indexing for array or batch execution.
+
+    Command Line Flags:
+        --config (str, optional):
+            Path to a Python or JSON configuration file. If not provided, the
+            configuration is read from the current working directory.
+
+        --dataset (str, optional):
+            Path to the dataset directory. Overrides
+            ``config.analysis.dataset`` in the configuration file.
+
+        --folder_output (str, optional):
+            Path to the output directory. Overrides output-related settings in
+            the configuration file. If not specified, output is written to the
+            current working directory.
+
+        --job_index (str, optional):
+            Comma-separated list of scenario or job indices to execute. If not
+            provided, the value is read from the environment variable specified
+            by ``--job_index_var``.
+
+        --job_index_var (str, optional):
+            Name of the environment variable containing the job index.
+            Defaults to ``SLURM_ARRAY_TASK_ID``.
+
+    Returns:
+        argparse.ArgumentParser: An argument parser configured for the
+        ZEN-Garden command-line interface.
+    """
+
+    description = (
+        "Run ZEN-Garden with a given config file. By default, the config file "
+        "is read from the current working directory. You may specify a config "
+        "file with --config. Output is always written to the current working "
+        "directory unless overridden."
+    )
+
+    parser = argparse.ArgumentParser(
+        description=description,
+        add_help=True,
+        usage="zen_garden [options]"
+    )
+
+    parser.add_argument(
+        "--config", type=str, required=False, default=None,
+        help="Path to a Python or JSON config file."
+    )
+    parser.add_argument(
+        "--dataset", type=str, required=False, default=None,
+        help="Path to the dataset directory. Overrides config.analysis.dataset."
+    )
+    parser.add_argument(
+        "--folder_output", type=str, required=False, default=None,
+        help="Path to the output directory. Overrides output settings in config."
+    )
+    parser.add_argument(
+        "--job_index", type=str, required=False, default=None,
+        help="Comma-separated list of scenario indices. If omitted, the "
+             "environment variable specified by --job_index_var is used."
+    )
+    parser.add_argument(
+        "--job_index_var", type=str, required=False,
+        default="SLURM_ARRAY_TASK_ID",
+        help="Environment variable for job index."
+    )
+
+    return parser
+
+def resolve_job_index(job_index:str, job_index_var:str) -> list[int]:
+    """
+    Resolves the job index when running ZEN-garden from the command line.
+
+    If the job index is directly specified using the ``job_index`` command-line
+    flag, those values are used. Otherwise, the job index is extracted from the
+    environment variable specified by the ``job_index_var`` command-line flag.
+    If neither is defined, ``None`` is returned.
+
+    Args:
+        job_index (str): Value of the ``job_index`` command-line flag provided
+            by the user.
+        job_index_var (str): Value of the ``job_index_var`` command-line flag
+            provided by the user.
+
+    Returns:
+        list[int] | None: List of job indices to run in the current instance of
+            ZEN-garden, or ``None`` if no job index is specified.
+    """
+
+    if job_index:
+        return [int(i) for i in job_index.split(",")]
+    elif ((env_value := os.environ.get(job_index_var)) is not None):
+        return [int(env_value)]
+    else:
+        return None
+
+
+def cli_zen_garden():
+    """
+    Entry point for the `zen-garden` command-line interface.
+    
+    This function creates the command-line interface for running ZEN-garden.
+    It first sets up an argument parser; extracts the job index (either from
+    the input flax directly or from an environment variable), and then
+    calls the ``zen_garden.run()`` function.
+
+    The ``[project.scripts]`` section of the pyproject.toml declares that 
+    this function will be called whenever a user enters ``zen-garden`` into
+    the command prompt.
+
+    Command Line Flags:
+        --config (str, optional):
+            Path to a Python or JSON configuration file. If not provided, the
+            configuration is read from the current working directory.
+
+        --dataset (str, optional):
+            Path to the dataset directory. Overrides
+            ``config.analysis.dataset`` in the configuration file.
+
+        --folder_output (str, optional):
+            Path to the output directory. Overrides output-related settings in
+            the configuration file. If not specified, output is written to the
+            current working directory.
+
+        --job_index (str, optional):
+            Comma-separated list of scenario or job indices to execute. If not
+            provided, the value is read from the environment variable specified
+            by ``--job_index_var``.
+
+        --job_index_var (str, optional):
+            Name of the environment variable containing the job index.
+            Defaults to ``SLURM_ARRAY_TASK_ID``.
+    Examples:
+        Basic usage in a command line prompt:
+
+        >>> zen-garden --config=".\config.json" --dataset="1_base_case"
+        
+    Returns:
+        None
+    """    
+    # parse command line arguments
+    parser = build_parser()
+    args = parser.parse_args()
+
+    ### get the job index
+    job_index = resolve_job_index(args.job_index, args.job_index_var)
+
+    run(
+        config=args.config,
+        dataset = args.dataset,
+        folder_output = args.folder_output,
+        job_index = job_index,
+    )

zen_garden-2.7.20/zen_garden/cli/zen_visualization.py

@@ -0,0 +1,24 @@
+from zen_temple.main import parse_arguments_and_run
+
+def cli_zen_visualization():
+    """
+    Entry point for the `zen-visualization` command-line interface.
+
+    This function initializes and runs the command-line interface (CLI)
+    for the ZEN-garden visualization platform. It delegates argument parsing
+    and command execution to the `parse_arguments_and_run` command of 
+    the ``ZEN-temple`` package.
+
+    The ``[project.scripts]`` section of the pyproject.toml declares that 
+    this function will be called whenever a user enters ``zen-visualization`` 
+    into the command prompt. 
+
+    Returns:
+        None
+
+    Examples:
+        Basic usage in a command line prompt:
+
+        >>> zen-visualization
+    """
+    parse_arguments_and_run()

{zen_garden-2.7.18 → zen_garden-2.7.20}/zen_garden/preprocess/unit_handling.py

@@ -729,7 +729,7 @@ class Scaling:
 
     def run_scaling(self):
         """
-        Runs the scaling algorithm. Function called in _internal.py.
+        Runs the scaling algorithm. Function called in runner.py.
         """
         logging.info(f"\n--- Start Scaling ---\n")
         t0 = time.perf_counter()

zen_garden-2.7.18/zen_garden/_internal.py → zen_garden-2.7.20/zen_garden/runner.py

@@ -3,26 +3,52 @@ This function runs ZEN garden,it is executed in the __main__.py script.
 Compilation  of the optimization problem.
 """
 import importlib.util
+from pathlib import Path
 import logging
 import os
 import importlib
 from .optimization_setup import OptimizationSetup
 from .postprocess.postprocess import Postprocess
 from .utils import setup_logger, InputDataChecks, StringUtils, ScenarioUtils
+import zen_garden.default_config as default_config
+import json
+import warnings
 
 # we setup the logger here
 setup_logger()
 
 
-def main(config, dataset_path=None, job_index=None, folder_output_path=None):
+def run(config = "./config.json", dataset=None, job_index=None, 
+               folder_output=None):
     """
-    This function runs ZEN garden,
-    it is executed in the __main__.py script
+    Run ZEN-garden.
 
-    :param config: A config instance used for the run
-    :param dataset_path: If not None, used to overwrite the config.analysis.dataset
-    :param job_index: The index of the scenario to run or a list of indices, if None, all scenarios are run in sequence
-    :param folder_output_path: If not None, used to overwrite the config.analysis.folder_output
+    This function is the primary programmatic entry point for running
+    ZEN-garden. When called, it reads the configuration, loads the model
+    input data, constructs and solves the optimization problem, and saves
+    the results.
+
+    Args:
+        config (str): Path to the configuration file (e.g. ``config.json``).
+            If the file is located in the current working directory, the
+            filename alone may be specified. Defaults to ``"./config.json"``.
+        dataset (str): Path to the folder containing the input dataset
+            (e.g. ``"./1_base_case"``). If located in the current working
+            directory, the folder name alone may be used. Defaults to the
+            ``dataset`` value specified in the configuration file.
+        folder_output (str): Path to the folder where outputs will be saved.
+            Defaults to ``"./outputs"``.
+        job_index (list[int] | None): Indices of jobs (scenarios) to run.
+            For example, ``job_index=[1]`` runs only the first scenario.
+            Defaults to ``None`` (run all jobs).
+
+    Returns:
+        OptimizationSetup: The fully set up and solved optimization problem.
+
+    Examples:
+        >>> from zen_garden import run, download_example_dataset
+        >>> download_example_dataset("1_base_case")
+        >>> run("1_base_case")
     """
 
     # print the version
@@ -32,13 +58,33 @@ def main(config, dataset_path=None, job_index=None, folder_output_path=None):
     # prevent double printing
     logging.propagate = False
 
+    ### import the config
+    if not os.path.exists(config):
+        config = config.replace(".py", ".json")
+    config_path, config_file = os.path.split(os.path.abspath(config))
+    if config_file.endswith(".py"):
+        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
+        warnings.warn(
+            "Use of the `config.py` file is deprecated and will be removed " \
+            "in ZEN-garden v3.0.0. Please switch to using a `config.json` " \
+            "file instead.",
+            DeprecationWarning,
+            stacklevel=2
+        )
+    else:
+        with open(Path(config_path) / config_file, "r") as f:
+            config = default_config.Config(**json.load(f))
+
     # overwrite the path if necessary
-    if dataset_path is not None:
+    if dataset is not 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 = os.path.abspath(folder_output_path)
-        config.solver.solver_dir = os.path.abspath(folder_output_path)
+        config.analysis.dataset = dataset
+    if folder_output is not None:
+        config.analysis.folder_output = os.path.abspath(folder_output)
+        config.solver.solver_dir = os.path.abspath(folder_output)
     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)
@@ -101,4 +147,4 @@ def main(config, dataset_path=None, job_index=None, folder_output_path=None):
                 Postprocess(optimization_setup, scenarios=config.scenarios, subfolder=subfolder,
                             model_name=model_name, scenario_name=scenario_name, param_map=param_map)
     logging.info("--- Optimization finished ---")
-    return optimization_setup
+    return optimization_setup

{zen_garden-2.7.18 → zen_garden-2.7.20}/zen_garden/utils.py

@@ -17,6 +17,10 @@ import shutil
 from copy import deepcopy
 from pathlib import Path
 from zen_garden.default_config import Subscriptable
+import requests
+from importlib.metadata import metadata
+import zipfile
+import io
 
 def setup_logger(level=logging.INFO):
     """ set up logger
@@ -45,74 +49,135 @@ def get_inheritors(klass):
                 work.append(child)
     return subclasses
 
+def download_example_dataset(dataset):
+    """ 
+    Downloads a dataset example to the current working directory. The function 
+    downloads the ZEN-garden dataset examples from the ZEN-garden Zenodo 
+    repository. It then extracts the dataset specified by the user and saves
+    it to the current working directory. In addition, it also downloads a 
+    ``config.json`` file and a Jupyter notebook demonstrating how to analyze
+    the results of a model. 
+
+    Args:
+        dataset (str): Name of the dataset to be downloaded. The following
+            options are currently available: "1_base_case", 
+            "2_multi_year_optimization", "3_reduced_import_availability", 
+            "4_PWA_nonlinear_capex", "5_multiple_time_steps_per_year",
+            "6_reduced_import_availability_yearly", "7_time_series_aggregation",
+            "8_yearly_variation", "9_myopic_foresight", "10_brown_field",
+            "11_multi_scenario", "12_multiple_in_output_carriers_conversion",
+            "13_yearly_interpolation", "14_retrofitting_and_fuel_substitution",
+            "15_unit_consistency_expected_error"
+
+    Returns:
+        tuple: 
+            str: The local path of the copied example
+            str: The local path of the copied config.json
+
+    Raises:
+        FileNotFoundError: If either the dataset or the config file could not 
+            be found in the Zenodo repository. 
+
+    Examples:
+        Basic usage example:
+
+        >>> from zen_garden.dataset_examples import download_dataset_example
+        >>> download_dataset_example("1_base_case")
 
-def copy_dataset_example(example):
-    """ copies a dataset example to the current working directory
-
-    :param example: The name of the example to copy
-    :return: The local path of the copied example
-    :return: The local path of the copied config.json
     """
-    import requests
-    from importlib.metadata import metadata
-    import zipfile
-    import io
+
+    # retrieve Zenodo metadata
     url = metadata("zen_garden").get_all("Project-URL")
     url = [u.split(", ")[1] for u in url if u.split(", ")[0] == "Zenodo"][0]
-    zenodo_meta = requests.get(url,allow_redirects=True)
+
+    # fetch Zenodo metadata
+    zenodo_meta = requests.get(url, allow_redirects=True)
     zenodo_meta.raise_for_status()
     zenodo_data = zenodo_meta.json()
     zenodo_zip_url = zenodo_data["files"][0]["links"]["self"]
+
+    # download ZIP file from Zenodo
     zenodo_zip = requests.get(zenodo_zip_url)
     zenodo_zip = zipfile.ZipFile(io.BytesIO(zenodo_zip.content))
+
+    # define relevant paths
     base_path = zenodo_zip.filelist[0].filename
-    example_path = f"{base_path}docs/dataset_examples/{example}/"
+    example_path = f"{base_path}docs/dataset_examples/{dataset}/"
     config_path = f"{base_path}docs/dataset_examples/config.json"
     notebook_path = f"{base_path}docs/dataset_examples/example_notebook.ipynb"
-    #local_dataset_path = os.path.join(os.getcwd(), "dataset_examples")
+
+    # create local directories
     local_dataset_path = os.getcwd()
     if not os.path.exists(local_dataset_path):
         os.mkdir(local_dataset_path)
-    local_example_path = os.path.join(local_dataset_path, example)
+    local_example_path = os.path.join(local_dataset_path, dataset)
     if not os.path.exists(local_example_path):
         os.mkdir(local_example_path)
+
+    # initialize flags for extracting files
     example_found = False
     config_found = False
     notebook_found = False
+
+    # search for example within ZIP file
     for file in zenodo_zip.filelist:
+
+        # download all files in dataset example
         if file.filename.startswith(example_path):
             filename_ending = file.filename.split(example_path)[1]
-            local_folder_path = os.path.join(local_example_path, filename_ending)
+            local_folder_path = os.path.join(
+                local_example_path, filename_ending)
             if file.is_dir():
                 if not os.path.exists(local_folder_path):
                     os.mkdir(os.path.join(local_example_path, filename_ending))
             else:
-                local_file_path = os.path.join(local_example_path, filename_ending)
+                local_file_path = os.path.join(
+                    local_example_path, filename_ending)
                 with open(local_file_path, "wb") as f:
                     f.write(zenodo_zip.read(file))
             example_found = True
+
+        # download config.json
         elif file.filename == config_path:
             with open(os.path.join(local_dataset_path, "config.json"), "wb") as f:
                 f.write(zenodo_zip.read(file))
             config_found = True
+
+        # download jupyter notebook
         elif file.filename == notebook_path:
-            notebook_path_local = os.path.join(local_dataset_path, "example_notebook.ipynb")
+            notebook_path_local = os.path.join(
+                local_dataset_path, "example_notebook.ipynb")
             notebook = json.loads(zenodo_zip.read(file))
             for cell in notebook['cells']:
                 if cell['cell_type'] == 'code':  # Check only code cells
                     for i, line in enumerate(cell['source']):
                         if "<dataset_name>" in line:
-                            cell['source'][i] = line.replace("<dataset_name>", example)
+                            cell['source'][i] = line.replace(
+                                "<dataset_name>", dataset)
             with open(notebook_path_local, "w") as f:
                 json.dump(notebook, f)
             notebook_found = True
-    assert example_found, f"Example {example} could not be downloaded from the dataset examples!"
-    assert config_found, f"Config.json file could not be downloaded from the dataset examples!"
+
+    # display status, errors, and warnings
+    if not example_found:
+        raise FileNotFoundError(
+            f"Example {dataset} could not be found in the dataset examples!"
+        )
+    if not config_found:
+        raise FileNotFoundError(
+            "Config.json file could not be downloaded from the dataset "
+            "examples!"
+        )
     if not notebook_found:
-        logging.warning("Example jupyter notebook could not be downloaded from the dataset examples!")
-    logging.info(f"Example dataset {example} downloaded to {local_example_path}")
-    return local_example_path, os.path.join(local_dataset_path, "config.json")
+        warnings.warn(
+            "Example jupyter notebook could not be downloaded from the "
+            "dataset examples!")
+
+    # print output
+    print(f"Example dataset {dataset} downloaded to {local_example_path}")
 
+    # return
+    return local_example_path, os.path.join(local_dataset_path, "config.json")
 
 # linopy helpers
 # --------------

zen_garden-2.7.18/zen_garden/__main__.py

@@ -1,77 +0,0 @@
-"""
-Runs the main function of ZEN-Garden.
-Compilation  of the optimization problem.
-"""
-from ._internal import main
-import importlib.util
-import argparse
-import sys
-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",
-               download_example = None):
-    """
-    Runs the main function of ZEN-Garden
-
-    :param args: Arguments to parse
-    """
-    if args is None:
-        args = sys.argv[1:]
-
-    # parse the args
-    description = "Run ZEN garden with a given config file. Per default, the config file will be read out from the " \
-                  "current working directory. You can specify a config file with the --config argument. However, " \
-                  "note that the output directory will always be the current working directory, independent of the " \
-                  "dataset specified in the config file."
-    parser = argparse.ArgumentParser(description=description, add_help=True, usage="usage: zen-garden [-h] [--config CONFIG] [--dataset DATASET] [--job_index JOB_INDEX] [--job_index_var JOB_INDEX_VAR] [-- download_example EXAMPLE_NAME]")
-    # TODO make json config default
-    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 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.")
-    parser.add_argument("--download_example", required=False, type=str, default=download_example, help="Downloads an example data set to the current working directory. The argument should be the name of a dataset example in documentation/dataset_examples. This command will copy the dataset and the config to the current folder. It will not run ZEN-garden.")
-
-    args = parser.parse_args(args)
-
-    # copy example dataset and run example
-    if args.download_example is not None:
-        example_path_cwd,config_path_cwd = copy_dataset_example(args.download_example)
-        return 
-
-    if not os.path.exists(args.config):
-        args.config = args.config.replace(".py", ".json")
-
-    ### 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", Path(config_path) / config_file)
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-        config = module.config
-    else:
-        with open(Path(config_path) / config_file, "r") as f:
-            config = default_config.Config(**json.load(f))
-
-    ### get the job index
-    job_index = args.job_index
-    if job_index is None:
-        if (job_index := os.environ.get(args.job_index_var)) is not None:
-            job_index = int(job_index)
-    else:
-        job_index = [int(i) for i in job_index.split(",")]
-
-    ### run
-    main(config=config, dataset_path=args.dataset, job_index=job_index, folder_output_path=args.folder_output)
-
-
-if __name__ == "__main__":
-
-    run_module()

zen_garden-2.7.18/zen_garden/visualization.py

@@ -1,4 +0,0 @@
-from zen_temple.main import parse_arguments_and_run
-
-if __name__ == "__main__":
-    parse_arguments_and_run()