xopt 3.2.1__tar.gz → 3.3.0__tar.gz

{xopt-3.2.1 → xopt-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xopt
-Version: 3.2.1
+Version: 3.3.0
 Summary: Flexible optimization of arbitrary problems in Python.
 Author: Christopher Mayes, Ryan Roussel, Nikita Kuklev, Christopher Pierce, Sara Miskovich
 License:                                  Apache License
@@ -305,11 +305,12 @@ Currenty **Xopt** provides:
   - `extremum_seeking` Extremum seeking time-dependent optimization
   - `rcds` Robust Conjugate Direction Search (RCDS)
   - `neldermead` Nelder-Mead Simplex
+  - `scipy` Scipy-based optimization algorithms (Powell, L-BFGS-B, etc.)
 - Sampling algorithms:
   - `random` Uniform random sampling
 - Convenient YAML/JSON based input format
 - Driver programs:
-  - `xopt.mpi.run` Parallel MPI execution using this input format
+  - `xopt-mpirun` Parallel MPI execution using this input format
 
 Xopt does **not** provide:
 - your custom simulation or experimental measurement via an `evaluate` function.
@@ -428,7 +429,7 @@ Using MPI
 ===============
 Example MPI run, with `xopt.yaml` as the only user-defined file:
 ```b
-mpirun -n 64 python -m mpi4py.futures -m xopt.mpi.run xopt.yaml
+mpirun -n 64 xopt-mpirun xopt.yaml
 ```
 
 

{xopt-3.2.1 → xopt-3.3.0}/README.md

@@ -53,11 +53,12 @@ Currenty **Xopt** provides:
   - `extremum_seeking` Extremum seeking time-dependent optimization
   - `rcds` Robust Conjugate Direction Search (RCDS)
   - `neldermead` Nelder-Mead Simplex
+  - `scipy` Scipy-based optimization algorithms (Powell, L-BFGS-B, etc.)
 - Sampling algorithms:
   - `random` Uniform random sampling
 - Convenient YAML/JSON based input format
 - Driver programs:
-  - `xopt.mpi.run` Parallel MPI execution using this input format
+  - `xopt-mpirun` Parallel MPI execution using this input format
 
 Xopt does **not** provide:
 - your custom simulation or experimental measurement via an `evaluate` function.
@@ -176,7 +177,7 @@ Using MPI
 ===============
 Example MPI run, with `xopt.yaml` as the only user-defined file:
 ```b
-mpirun -n 64 python -m mpi4py.futures -m xopt.mpi.run xopt.yaml
+mpirun -n 64 xopt-mpirun xopt.yaml
 ```
 
 

{xopt-3.2.1 → xopt-3.3.0}/docs/algorithms.md

@@ -65,7 +65,8 @@ Scipy Generators
 These generators serve as wrappers for algorithms implemented in scipy.
 
 - [`NelderMeadGenerator`](examples/sequential/neldermead.ipynb): implements Nelder-Mead (simplex) optimization.
-- [`LatinHypercubeGenerator`](examples/scipy/latin_hypercube.ipynb): perform latin hypercube sampling of the evaluation function.
+- [`ScipyGenerator`](examples/sequential/scipy.ipynb): generic wrapper around `scipy.optimize.minimize` methods.
+- [`LatinHypercubeGenerator`](examples/other/latin_hypercube.ipynb): performs latin hypercube sampling of the evaluation function.
 
 RCDS Generators
 ===

xopt-3.3.0/docs/api/generators/sequential/scipy.md

@@ -0,0 +1,80 @@
+# Scipy Minimize Generator
+
+`ScipyGenerator` exposes scipy's `optimize.minimize` methods through Xopt's sequential ingest/suggest interface.
+
+## Integration Model
+
+Xopt evaluates objective functions externally, one point at a time. `scipy.optimize.minimize` expects an in-process callable objective. `ScipyGenerator` bridges this mismatch by running one persistent scipy session in a worker thread:
+
+1. A cache is built from prior evaluations (`data`) keyed by rounded variable values.
+2. A single `minimize` call starts in a background thread.
+3. The objective callback first checks the cache.
+4. For an uncached point, that point is pushed to Xopt via a request queue.
+5. Xopt evaluates the point externally and calls `add_data`.
+6. The objective value is sent back through a response queue, and the same scipy run continues from in-memory state.
+
+Only the first `add_data` call answering a pending request sends a response to
+scipy. Repeated submissions of the same candidate remain in the data history,
+but cannot answer a later request. Values are also cached under the requested
+coordinates, so small readback differences accepted by sequential point
+validation do not cause cache misses after a session restart.
+
+## Performance Notes
+
+- Cache reconstruction is O(N) when a session starts or data is reloaded.
+- The active scipy run is maintained between `step` calls; `minimize` is not restarted each step.
+- Keys are rounded to 12 decimals before cache lookup to reduce floating-point key mismatch issues.
+
+## Supported Methods
+
+`method` is validated against bounded scipy methods supported by this wrapper:
+
+- `Nelder-Mead`
+- `Powell`
+- `L-BFGS-B`
+- `TNC`
+- `SLSQP`
+- `trust-constr`
+- `COBYLA`
+- `COBYQA`
+
+Invalid or empty method names fail validation.
+
+## Session Lifecycle and Errors
+
+- `reset()` stops the active worker session and clears the result and completion state.
+- `set_data(...)` stops any active session, clears completion state, reloads data, and rebuilds the cache.
+- Each worker retains its own stop event, queues, and cache. Shutdown waits up to two seconds and warns if the worker is still running in scipy; that worker cannot consume responses or publish requests, results, or errors into a subsequent session.
+- `result` exposes scipy's `OptimizeResult` after termination, including `success`, `message`, and solver-specific fields such as `nit`. It is `None` before termination.
+- `is_done` is true once scipy terminates, including unsuccessful termination (for example, reaching an iteration limit). Check `result.success` to distinguish successful convergence.
+- Once terminated, later `generate()` calls do not restart scipy or rebuild the cache. For compatibility, they still return the latest known data row, with a `RuntimeWarning` emitted once per session on this fallback path. Further explicit `Xopt.step()` calls will re-evaluate and append this duplicate; stop stepping when `generator.is_done` is true.
+- Common scipy `ValueError` messages are remapped to clearer runtime errors (for example unsupported solver availability or bound handling).
+
+## State Restoration
+
+For model-level roundtrips, use pydantic serialization:
+
+- `model_dump()`
+- `model_validate(...)`
+
+Then restore the evaluation history with `set_data(...)` so the cache and last outcome are reconstructed before continuing optimization.
+
+The class also defines `__getstate__` and `__setstate__` for explicit state handling of non-picklable runtime thread objects.
+Pickling does not stop the original worker. Pickle and deep-copy roundtrips retain
+completed results and the completion latch without sharing runtime thread objects;
+model-level roundtrips restart from the restored evaluation history instead.
+Requested-coordinate cache entries are retained through `reset()`, pickle, and
+deep-copy roundtrips. Replacing the dataset with `set_data(...)` clears these
+entries; model-level roundtrips rebuild from observed coordinates in the restored
+history.
+
+## Configuration
+
+Typical fields:
+
+- `method`: scipy minimization method name, e.g. `Powell`, `Nelder-Mead`, `L-BFGS-B`.
+- `initial_point`: optional starting point dictionary.
+- `tol`, `options`: passed directly to `scipy.optimize.minimize`.
+- `scipy_kwargs`: additional keyword arguments forwarded to scipy.
+
+::: xopt.generators.sequential.scipy

xopt-3.3.0/docs/api/stopping_conditions.md

@@ -0,0 +1,33 @@
+# Stopping Conditions
+
+## Maximum elapsed time
+
+Use `MaxTimeCondition` to stop after a positive, finite number of wall-clock
+seconds:
+
+```python
+from xopt.stopping_conditions import MaxTimeCondition
+
+X.stopping_condition = MaxTimeCondition(max_time=60.0)
+X.run()
+```
+
+The timer starts when `should_stop()` is first called, normally at the start of
+`run()`, and uses a monotonic clock. Time before that first check is not counted.
+Conditions are checked between optimization steps, so an
+in-progress evaluation is allowed to finish and the time limit may be exceeded.
+The condition also works without evaluation data and can be nested inside a
+`CompositeCondition`.
+
+For YAML configuration:
+
+```yaml
+stopping_condition:
+  name: MaxTimeCondition
+  max_time: 60.0
+```
+
+Only the time limit is serialized. Loading a saved configuration resets the
+timer; the full time budget starts at the first check.
+
+::: xopt.stopping_conditions

{xopt-3.2.1 → xopt-3.3.0}/docs/index.md

@@ -42,12 +42,13 @@ Currenty **Xopt** provides:
     - [`extremum_seeking`](examples/sequential/extremum_seeking.ipynb) Extremum seeking time-dependent optimization
     - [`rcds`](examples/sequential/rcds.ipynb) Robust Conjugate Direction Search (RCDS)
     - [`neldermead`](examples/sequential/neldermead.ipynb) Nelder-Mead Simplex
+    - [`scipy`](examples/sequential/scipy.ipynb) Scipy-based optimization algorithms (Powell, L-BFGS-B, etc.)
 - Sampling algorithms:
     - `random` Uniform random sampling
 - Convenient YAML/JSON based input format
 - Driver programs:
-    - [`xopt-run`](examples/basic/xopt_cli.md) Run Xopt from the command line using a YAML config file
-    - `xopt.mpi.run` Parallel MPI execution using this input format
+    - [`xopt-run`](examples/basic/xopt_cli.md#xopt-run-usage) Run Xopt from the command line using a YAML config file
+    - [`xopt-mpirun`](examples/basic/xopt_cli.md#xopt-mpirun-usage) Parallel MPI execution using this input format
 
  **Xopt** does **not** provide:
 - your custom simulation via an `evaluate` function.
@@ -151,7 +152,7 @@ Using MPI
 ===============
 Example MPI run, with `xopt.yaml` as the only user-defined file:
 ```b
-mpirun -n 64 python -m mpi4py.futures -m xopt.mpi.run xopt.yaml
+mpirun -n 64 xopt-mpirun xopt.yaml
 ```
 
 

{xopt-3.2.1 → xopt-3.3.0}/environment.yml

@@ -15,6 +15,7 @@ dependencies:
   - tqdm
   - orjson
   - matplotlib
+  - gest-api>=0.2
 # parallel
   - mpi4py
   - dask
@@ -33,3 +34,4 @@ dependencies:
   - mkdocstrings-python
   - ruff
   - typing-extensions
+  - gest-api

{xopt-3.2.1 → xopt-3.3.0}/mkdocs.yml

@@ -63,11 +63,12 @@ nav:
               - Genetic operators: examples/ga/nsga2/genetic_operators.ipynb
 
         - Sequential:
+            - Scipy Minimize: examples/sequential/scipy.ipynb
             - Nelder-Mead: examples/sequential/neldermead.ipynb
             - Extremum seeking: examples/sequential/extremum_seeking.ipynb
             - RCDS: examples/sequential/rcds.ipynb
         - Other:
-            - Latin Hypercube: examples/scipy/latin_hypercube.ipynb
+            - Latin Hypercube: examples/other/latin_hypercube.ipynb
         - Developer:
             - Benchmarking & Profiling: examples/developer/benchmarking.md
 
@@ -105,6 +106,7 @@ nav:
               - Genetic Operators: api/generators/ga/operators.md
           - Sequential generators:
               - Sequential Base Class: api/generators/sequential/sequential_generator.md
+              - Scipy Minimize: api/generators/sequential/scipy.md
               - RCDS: api/generators/sequential/rcds.md
               - Extremum Seeking: api/generators/sequential/extremumseeking.md
               - Nelder-Mead: api/generators/sequential/neldermead.md

{xopt-3.2.1 → xopt-3.3.0}/pyproject.toml

@@ -71,7 +71,8 @@ doc = [
 Homepage = "https://github.com/xopt-org/xopt"
 
 [project.scripts]
-xopt-run = "xopt.entrypoint:main"
+xopt-run = "xopt.entrypoint.multiprocessing:main"
+xopt-mpirun = "xopt.entrypoint.mpi:main"
 
 [options]
 zip_safe = false

{xopt-3.2.1 → xopt-3.3.0}/xopt/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.2.1'
-__version_tuple__ = version_tuple = (3, 2, 1)
+__version__ = version = '3.3.0'
+__version_tuple__ = version_tuple = (3, 3, 0)
 
-__commit_id__ = commit_id = 'g46cc86a6b'
+__commit_id__ = commit_id = 'gf13d21cd6'

{xopt-3.2.1 → xopt-3.3.0}/xopt/asynchronous.py

@@ -159,6 +159,13 @@ class AsynchronousXopt(Xopt):
 
         self.add_data(new_data)
 
+        # dump to file(s) if specified
+        if len(new_data):
+            if self.xopt_dump_file is not None:
+                self.dump()
+            if self.data_dump_file is not None:
+                self.dump_data()
+
         # Cleanup
         self._input_data.drop(index, inplace=True)
 

{xopt-3.2.1 → xopt-3.3.0}/xopt/base.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import os
 from copy import deepcopy
 from typing import Any, Optional, Union
 
@@ -40,6 +41,11 @@ from .errors import DataError
 
 logger = logging.getLogger(__name__)
 
+DUMP_FILE_RENAME_MESSAGE = (
+    "The attribute `dump_file` in `Xopt` has been renamed to `xopt_dump_file`. "
+    "Support for the old name will be removed in later versions of the Xopt library."
+)
+
 
 class Xopt(XoptBaseModel):
     """
@@ -59,9 +65,13 @@ class Xopt(XoptBaseModel):
     strict : bool, optional
         A flag indicating whether exceptions raised during evaluation should stop the
         optimization process.
-    dump_file : str, optional
+    xopt_dump_file : str, optional
         An optional file path for dumping attributes of the xopt object and the
-        results of evaluations.
+        results of evaluations. Environment variables and `~` are expanded when
+        dumping.
+    data_dump_file : str, optional
+        An optional file path for dumping the evaluation data as a CSV file.
+        Environment variables and `~` are expanded when dumping.
     data : DataFrame, optional
         An optional DataFrame object for storing internal data related to the optimization
         process.
@@ -98,6 +108,8 @@ class Xopt(XoptBaseModel):
         Serializes the Xopt configuration to a YAML string.
     dump(file: str = None, **kwargs)
         Dumps the Xopt configuration to a specified file.
+    dump_data()
+        Dumps the evaluation data to the file given by `data_dump_file`.
     dict(**kwargs) -> dict
         Provides a custom dictionary representation of the Xopt configuration.
     json(**kwargs) -> str
@@ -115,8 +127,11 @@ class Xopt(XoptBaseModel):
         description="flag to indicate if exceptions raised during evaluation "
         "should stop Xopt",
     )
-    dump_file: Optional[str] = Field(
-        None, description="file to dump the results of the evaluations"
+    xopt_dump_file: Optional[str] = Field(
+        None, description="file to dump the serialized Xopt object to"
+    )
+    data_dump_file: Optional[str] = Field(
+        None, description="file to dump the evaluation data to as CSV"
     )
     data: Optional[DataFrame] = Field(None, description="internal DataFrame object")
     serialize_torch: bool = Field(
@@ -243,6 +258,35 @@ class Xopt(XoptBaseModel):
             )
         return data
 
+    @model_validator(mode="before")
+    @classmethod
+    def dump_file_legacy(cls, data: Any):
+        """
+        Handle backward compatibility: convert the old dump_file parameter to
+        xopt_dump_file.
+        """
+        if isinstance(data, dict) and "dump_file" in data:
+            warnings.warn(DUMP_FILE_RENAME_MESSAGE, DeprecationWarning, stacklevel=2)
+            dump_file = data.pop("dump_file")
+            if dump_file is not None:
+                if data.get("xopt_dump_file") is not None:
+                    raise ValueError(
+                        "Cannot specify both 'dump_file' and 'xopt_dump_file'. "
+                        "Use 'xopt_dump_file' instead."
+                    )
+                data["xopt_dump_file"] = dump_file
+        return data
+
+    @property
+    def dump_file(self) -> Optional[str]:
+        warnings.warn(DUMP_FILE_RENAME_MESSAGE, DeprecationWarning, stacklevel=2)
+        return self.xopt_dump_file
+
+    @dump_file.setter
+    def dump_file(self, value: Optional[str]):
+        warnings.warn(DUMP_FILE_RENAME_MESSAGE, DeprecationWarning, stacklevel=2)
+        self.xopt_dump_file = value
+
     @property
     def n_data(self) -> int:
         if self.data is None:
@@ -347,8 +391,8 @@ class Xopt(XoptBaseModel):
         while True:
             # Check custom stopping condition
             if self.stopping_condition is not None:
-                if self.data is not None and self.stopping_condition.should_stop(
-                    self.data, self.vocs
+                if self.stopping_condition.should_stop(
+                    self.data if self.data is not None else pd.DataFrame(), self.vocs
                 ):
                     logger.info("Xopt is done. Stopping condition met.")
                     break
@@ -440,9 +484,11 @@ class Xopt(XoptBaseModel):
 
         self.add_data(output_data)
 
-        # dump data to file if specified
-        if self.dump_file is not None:
+        # dump to file(s) if specified
+        if self.xopt_dump_file is not None:
             self.dump()
+        if self.data_dump_file is not None:
+            self.dump_data()
 
         return output_data
 
@@ -493,6 +539,9 @@ class Xopt(XoptBaseModel):
         except DataError as exc:
             if self.strict:
                 raise exc
+            warnings.warn(
+                f"Generator rejected {len(new_data)} new data point(s) (strict=False): {exc}"
+            )
 
     def reset_data(self):
         """
@@ -624,31 +673,58 @@ class Xopt(XoptBaseModel):
 
     def dump(self, file: str = None, **kwargs):
         """
-        Dump data to a file.
+        Dump the Xopt configuration and data to a YAML file.
+
+        Environment variables and `~` in the path are expanded.
 
         Parameters
         ----------
         file : str, optional
             The path to the file where the Xopt configuration will be dumped.
+            Defaults to the `xopt_dump_file` attribute.
         **kwargs
             Additional keyword arguments for customizing the dump.
 
         Raises
         ------
         ValueError
-            If no dump file is specified via argument or in the `dump_file` attribute.
+            If no dump file is specified via argument or in the `xopt_dump_file`
+            attribute.
 
         """
-        fname = file if file is not None else self.dump_file
+        fname = file if file is not None else self.xopt_dump_file
 
         if fname is None:
             raise ValueError(
-                "no dump file specified via argument or in `dump_file` attribute"
+                "no dump file specified via argument or in `xopt_dump_file` attribute"
             )
-        else:
-            with open(fname, "w") as f:
-                f.write(self.yaml(**kwargs))
-            logger.debug(f"Dumped state to YAML file: {fname}")
+
+        fname = os.path.expanduser(os.path.expandvars(fname))
+        with open(fname, "w") as f:
+            f.write(self.yaml(**kwargs))
+        logger.debug(f"Dumped state to YAML file: {fname}")
+
+    def dump_data(self):
+        """
+        Dump the evaluation data to the CSV file given by `data_dump_file`.
+
+        Environment variables and `~` in the path are expanded.
+
+        Raises
+        ------
+        ValueError
+            If no data dump file is specified in the `data_dump_file` attribute.
+
+        """
+        if self.data_dump_file is None:
+            raise ValueError(
+                "no data dump file specified in `data_dump_file` attribute"
+            )
+
+        fname = os.path.expanduser(os.path.expandvars(self.data_dump_file))
+        data = self.data if self.data is not None else pd.DataFrame()
+        data.to_csv(fname, index_label="xopt_index")
+        logger.debug(f"Dumped data to CSV file: {fname}")
 
     def dict(self, **kwargs) -> dict:
         """

xopt-3.3.0/xopt/entrypoint/__init__.py

@@ -0,0 +1 @@
+__all__ = []

xopt-3.3.0/xopt/entrypoint/mpi.py

@@ -0,0 +1,172 @@
+from mpi4py import MPI
+from mpi4py.futures import MPICommExecutor
+import argparse
+import logging
+import os
+import pandas as pd
+import sys
+import yaml
+
+from xopt import AsynchronousXopt
+from xopt.base import Xopt
+from xopt.entrypoint.utils import (
+    merge_dicts,
+    normalize_initial_data,
+    override_to_dict,
+    setup_import_paths,
+)
+from xopt.log import set_handler_with_logger
+from xopt.pydantic import remove_none_values
+
+
+comm = MPI.COMM_WORLD
+mpi_rank = comm.Get_rank()
+mpi_size = comm.Get_size()
+
+logger = logging.getLogger("xopt")
+
+
+def run_mpi(
+    config,
+    verbosity=None,
+    asynchronous=True,
+    logfile=None,
+    python_path=None,
+    initial_data=None,
+):
+    """
+    Xopt MPI driver
+
+    Basic usage:
+
+    mpirun -n 4 xopt-mpirun xopt.yaml
+
+    Parameters
+    ----------
+    config : dict
+        Xopt configuration.
+    verbosity : int, optional
+        Verbosity count controlling the log level.
+    asynchronous : bool, default=True
+        Run with AsynchronousXopt instead of Xopt.
+    logfile : str, optional
+        File log messages are written to.
+    python_path : list of str, optional
+        Directories added to the module search path on every rank. Worker ranks import
+        the evaluation function themselves, so this must run before the Xopt object is
+        built.
+    initial_data : str, optional
+        CSV file of existing data used to seed the generator, read on the root rank.
+    """
+
+    level = "WARN"
+    if verbosity:
+        iv = verbosity
+        if iv == 1:
+            level = "WARN"
+        elif iv == 2:
+            level = "INFO"
+        elif iv >= 3:
+            level = "DEBUG"
+
+        set_handler_with_logger(level=level)
+
+    if logfile:
+        set_handler_with_logger(file=logfile, level=level)
+
+    setup_import_paths(python_path or [])
+
+    # logger.info(xopt_logo)
+    # logger.info('_________________________________')
+    logger.info(f"Parallel execution with {mpi_size} workers")
+
+    if asynchronous:
+        logger.info("Enabling async mode")
+        X = AsynchronousXopt(**config)
+    else:
+        X = Xopt(**config)
+
+    if mpi_rank == 0:
+        print(X)
+        sys.stdout.flush()
+
+    # Launch MPI executor (it is None for the workers)
+    with MPICommExecutor(MPI.COMM_WORLD, root=0) as executor:
+        if executor is not None:
+            X.evaluator.executor = executor
+            X.evaluator.max_workers = mpi_size
+
+            if initial_data is not None:
+                logger.info(f"Loading initial data from {initial_data}")
+                X.add_data(normalize_initial_data(pd.read_csv(initial_data), X.vocs))
+
+            X.run()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Configure xopt")
+    parser.add_argument("input_file", help="input_file")
+    parser.add_argument("--logfile", "-l", help="Log file to write to")
+    parser.add_argument("--verbose", "-v", action="count", help="Show more log output")
+    parser.add_argument(
+        "--asynchronous",
+        "-a",
+        action=argparse.BooleanOptionalAction,
+        help="Use asynchronous execution",
+        default=True,
+    )
+    parser.add_argument(
+        "--python_path",
+        help="Additional path to add to Python import path for evaluation function module search",
+        action="append",
+        default=[],
+    )
+    parser.add_argument(
+        "--override",
+        help="Override config values using dot notation (e.g., generator.mutation_operator.eta_m=20)",
+        action="append",
+        default=[],
+    )
+    parser.add_argument(
+        "--initial_data",
+        help="CSV file with initial data to seed the generator before running",
+        type=str,
+        default=None,
+    )
+
+    args = parser.parse_args()
+    if mpi_rank == 0:
+        print(args)
+
+    input_file = args.input_file
+    logfile = args.logfile
+    verbosity = args.verbose
+    asynchronous = args.asynchronous
+
+    if not os.path.exists(input_file):
+        if mpi_rank == 0:
+            print(f"Input file does not exist: {input_file}", file=sys.stderr)
+        sys.exit(1)
+
+    with open(input_file) as f:
+        config = yaml.safe_load(f)
+        config = remove_none_values(config)
+
+    if args.override:
+        logger.info("Applying config file overrides:")
+    for override in args.override:
+        logger.info(f"  {override}")
+        config = merge_dicts(config, override_to_dict(override))
+
+    run_mpi(
+        config,
+        verbosity=verbosity,
+        logfile=logfile,
+        asynchronous=asynchronous,
+        python_path=[os.getcwd()] + args.python_path,
+        initial_data=args.initial_data,
+    )
+
+
+if __name__ == "__main__":
+    main()