interaction-eda-step 2026.11.7__py2.py3-none-any.whl

interaction_eda_step/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""
+interaction_eda_step
+A SEAMM plug-in for Interaction EDA
+"""
+
+# Bring up the classes so that they appear to be directly in
+# the interaction_eda_step package.
+
+from .interaction_eda import InteractionEda  # noqa: F401, E501
+from .interaction_eda_parameters import InteractionEdaParameters  # noqa: F401, E501
+from .interaction_eda_step import InteractionEdaStep  # noqa: F401, E501
+from .tk_interaction_eda import TkInteractionEda  # noqa: F401, E501
+
+from .metadata import metadata  # noqa: F401
+
+# Handle versioneer
+from ._version import get_versions
+
+__author__ = "Paul Saxe"
+__email__ = "psaxe@molssi.org"
+versions = get_versions()
+__version__ = versions["version"]
+__git_revision__ = versions["full-revisionid"]
+del get_versions, versions

interaction_eda_step/__main__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+"""Handle the installation of the Interaction EDA step."""
+
+from .installer import Installer
+
+
+def run():
+    """Handle the extra installation needed.
+
+    * Create the conda environment `seamm-gpu4pyscf` with GPU4PySCF for this
+      machine's NVIDIA driver.
+    * Add or update information in the SEAMM gpu4pyscf.ini file.
+    """
+    installer = Installer()
+    installer.run()
+
+
+if __name__ == "__main__":
+    run()

interaction_eda_step/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.18) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2026-11-07T13:51:33-0500",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "b97b2b9549560991799ed04f040db639cacc76d0",
+ "version": "2026.11.7"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

interaction_eda_step/backends/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+"""The codes that do the energy decomposition (see :mod:`.base`)."""
+
+from .base import Backend, Calculation, Result, read_jsonl  # noqa: F401
+from .gpu4pyscf import GPU4PySCF  # noqa: F401
+
+#: The backends by name.
+BACKENDS = {b.name: b for b in (GPU4PySCF,)}

interaction_eda_step/backends/base.py

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+
+"""The interface between the Interaction EDA step and the codes that do the EDA.
+
+A backend runs a batch of EDA calculations, one per set of fragments, in its own
+environment through ``seamm_exec``. The step knows only this interface:
+
+* what the backend can do (:attr:`Backend.scheme`, :attr:`Backend.device`,
+  :attr:`Backend.max_fragments`, :meth:`Backend.options`), so the GUI can offer
+  only valid choices;
+* :meth:`Backend.files` -- the input files for a batch;
+* :attr:`Backend.ini` and :meth:`Backend.command` -- how ``seamm_exec`` runs it;
+* :meth:`Backend.read_results` -- the native terms of each calculation, kJ/mol.
+
+Backends planned: ``gpu4pyscf`` (ALMO-EDA2 on a GPU), ``psi4_almo`` (ALMO-EDA2 on
+CPUs) and ``psi4_sapt`` (SAPT0/F-SAPT, dimers only).
+"""
+
+from dataclasses import dataclass, field
+import json
+from pathlib import Path
+
+
+@dataclass
+class Calculation:
+    """One EDA calculation: a set of fragments.
+
+    Attributes
+    ----------
+    key : tuple(int, ...)
+        Ascending fragment indices.
+    fragments : [interaction_eda_step.fragments.Fragment]
+    """
+
+    key: tuple
+    fragments: list
+
+    @property
+    def id(self):
+        return "+".join(str(k) for k in self.key)
+
+
+@dataclass
+class Result:
+    """The outcome of one calculation.
+
+    Attributes
+    ----------
+    key : tuple(int, ...)
+    energies : {str: float} or None
+        Native terms, kJ/mol; None if it failed.
+    error : str or None
+    data : dict
+        Everything else the backend reports (timing, memory, versions, ...).
+    """
+
+    key: tuple
+    energies: dict = None
+    error: str = None
+    data: dict = field(default_factory=dict)
+
+
+class Backend:
+    """Base class for the EDA backends."""
+
+    #: Short name, used in the parameters and the ini file name.
+    name = None
+    #: The EDA scheme (a key of :data:`interaction_eda_step.terms.SCHEMES`).
+    scheme = None
+    #: "gpu" or "cpu".
+    device = "cpu"
+    #: The most fragments in one calculation; None for no limit.
+    max_fragments = None
+    #: The ini file (in the installation's root) that says how to run the code.
+    ini = None
+    #: Results file the code writes.
+    results_file = "results.jsonl"
+
+    def options(self):
+        """The settings this backend accepts: {name: default}."""
+        return {}
+
+    def files(self, calculations, settings):
+        """The input files for a batch of calculations: {name: text}."""
+        raise NotImplementedError
+
+    def command(self):
+        """The command line, with ``{code}`` from the ini file."""
+        raise NotImplementedError
+
+    def read_results(self, directory, calculations):
+        """{key: Result} for the calculations, from the results file.
+
+        A calculation with no result is reported with an error.
+        """
+        raise NotImplementedError
+
+    def method_string(self, settings):
+        """A one-line description of the method, for labels and tables."""
+        raise NotImplementedError
+
+    def citations(self, settings):
+        """[(alias, bibtex, level, note)] to cite."""
+        return []
+
+
+def read_jsonl(path):
+    """The records of a JSON-lines file; later records replace earlier ones
+    with the same id (a rerun after a failure)."""
+    records = {}
+    path = Path(path)
+    if path.exists():
+        for line in path.read_text().splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                record = json.loads(line)
+            except ValueError:
+                continue
+            old = records.get(record.get("id"))
+            if old is None or "error" in old or "error" not in record:
+                records[record.get("id")] = record
+    return records

interaction_eda_step/backends/gpu4pyscf.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+
+"""ALMO-EDA2 with GPU4PySCF on a GPU."""
+
+import importlib.resources
+import json
+from pathlib import Path
+
+from .base import Backend, Result, read_jsonl
+
+DRIVER = "gpu4pyscf_eda.py"
+
+# The settings validated against SAPT and CCSD(T) and on ChemAI and ARC
+# (2026-11-06): wB97M-V/def2-TZVPD, no density fitting, FERF SVD threshold 1e-4,
+# coupled FERF-DQ response.
+DEFAULTS = {
+    "xc": "wb97m-v",
+    "basis": "def2-tzvpd",
+    "auxbasis": None,
+    "nlc": None,
+    "disp": None,
+    "svd_threshold": 1.0e-4,
+    "ferf": "coupled",
+    "response_nlc": True,
+    "allow_low_fp64": False,
+    "verbose": 3,
+}
+
+BIBTEX = {
+    "gpu4pyscf": (
+        "@article{gpu4pyscf,\n"
+        "  title = {Introducing {GPU} Acceleration into the {Python}-Based"
+        " Simulations of Chemistry Framework},\n"
+        "  author = {Li, Rui and Sun, Qiming and Zhang, Xing and Chan, Garnet"
+        " Kin-Lic},\n"
+        "  journal = {J. Phys. Chem. A},\n"
+        "  volume = {129},\n  number = {5},\n  pages = {1459--1468},\n"
+        "  year = {2025},\n"
+        "  doi = {10.1021/acs.jpca.4c05876}\n}"
+    ),
+    "pyscf": (
+        "@article{pyscf2020,\n"
+        "  title = {Recent developments in the {PySCF} program package},\n"
+        "  author = {Sun, Qiming and others},\n"
+        "  journal = {J. Chem. Phys.},\n"
+        "  volume = {153},\n  pages = {024109},\n  year = {2020},\n"
+        "  doi = {10.1063/5.0006074}\n}"
+    ),
+    "almo_eda2": (
+        "@article{almo_eda2,\n"
+        "  title = {Probing non-covalent interactions with a second generation"
+        " energy decomposition analysis using absolutely localized molecular"
+        " orbitals},\n"
+        "  author = {Horn, Paul R. and Mao, Yuezhi and Head-Gordon, Martin},\n"
+        "  journal = {Phys. Chem. Chem. Phys.},\n"
+        "  volume = {18},\n  pages = {23067--23079},\n  year = {2016},\n"
+        "  doi = {10.1039/C6CP03784D}\n}"
+    ),
+    "frozen": (
+        "@article{almo_eda_frozen,\n"
+        "  title = {Defining the contributions of permanent electrostatics,"
+        " {Pauli} repulsion, and dispersion in density functional theory"
+        " calculations of intermolecular interaction energies},\n"
+        "  author = {Horn, Paul R. and Mao, Yuezhi and Head-Gordon, Martin},\n"
+        "  journal = {J. Chem. Phys.},\n"
+        "  volume = {144},\n  pages = {114107},\n  year = {2016},\n"
+        "  doi = {10.1063/1.4942921}\n}"
+    ),
+    "ferf": (
+        "@article{ferf,\n"
+        "  title = {Polarization contributions to intermolecular interactions"
+        " revisited with fragment electric-field response functions},\n"
+        "  author = {Horn, Paul R. and Head-Gordon, Martin},\n"
+        "  journal = {J. Chem. Phys.},\n"
+        "  volume = {143},\n  pages = {114111},\n  year = {2015},\n"
+        "  doi = {10.1063/1.4930534}\n}"
+    ),
+}
+
+
+class GPU4PySCF(Backend):
+    """Second-generation ALMO-EDA in GPU4PySCF (1.9 or later)."""
+
+    name = "GPU4PySCF"
+    scheme = "ALMO-EDA2"
+    device = "gpu"
+    max_fragments = None
+    ini = "gpu4pyscf.ini"
+
+    def options(self):
+        return dict(DEFAULTS)
+
+    def settings(self, settings):
+        """The full settings: the defaults updated with those given."""
+        out = dict(DEFAULTS)
+        out.update({k: v for k, v in (settings or {}).items() if k in DEFAULTS})
+        return out
+
+    def files(self, calculations, settings):
+        data = {
+            "settings": self.settings(settings),
+            "calculations": [
+                {
+                    "id": calc.id,
+                    "fragments": [
+                        {
+                            "label": f.label(),
+                            "symbols": list(f.symbols),
+                            "coordinates": [
+                                [float(x) for x in row] for row in f.coordinates
+                            ],
+                            "charge": int(f.charge),
+                            "spin": int(f.multiplicity) - 1,
+                        }
+                        for f in calc.fragments
+                    ],
+                }
+                for calc in calculations
+            ],
+        }
+        driver = (
+            importlib.resources.files("interaction_eda_step") / "data" / DRIVER
+        ).read_text()
+        return {
+            "input.json": json.dumps(data, indent=1),
+            DRIVER: driver,
+        }
+
+    def command(self):
+        # The logs go in the step's directory, not a subdirectory: the executor's
+        # in-situ clean-up (seamm_exec 2026.11.5) cannot remove a new directory
+        # holding files it returns.
+        return [
+            "{code}",
+            DRIVER,
+            "input.json",
+            "-o",
+            self.results_file,
+            "--logdir",
+            ".",
+        ]
+
+    def read_results(self, directory, calculations):
+        records = read_jsonl(Path(directory) / self.results_file)
+        out = {}
+        for calc in calculations:
+            record = records.get(calc.id)
+            if record is None:
+                out[calc.key] = Result(calc.key, error="no result (not run?)")
+            elif "error" in record and "eda_kJ_mol" not in record:
+                out[calc.key] = Result(calc.key, error=record["error"], data=record)
+            else:
+                out[calc.key] = Result(
+                    calc.key,
+                    energies={k: float(v) for k, v in record["eda_kJ_mol"].items()},
+                    data=record,
+                )
+        return out
+
+    def method_string(self, settings):
+        s = self.settings(settings)
+        parts = [
+            f"scheme={self.scheme}",
+            f"backend={self.name}",
+            f"xc={s['xc']}",
+            f"basis={s['basis']}",
+            f"auxbasis={s['auxbasis'] or 'none'}",
+            f"nlc={'default' if s['nlc'] is None else s['nlc']}",
+            f"response_nlc={'on' if s['response_nlc'] else 'off'}",
+            f"disp={s['disp'] or 'none'}",
+            f"ferf={s['ferf']}",
+            f"svd_threshold={s['svd_threshold']:g}",
+        ]
+        return ";".join(parts)
+
+    def citations(self, settings):
+        return [
+            ("gpu4pyscf", BIBTEX["gpu4pyscf"], 1, "The GPU4PySCF code."),
+            ("pyscf2020", BIBTEX["pyscf"], 1, "PySCF, which GPU4PySCF builds on."),
+            ("almo_eda2", BIBTEX["almo_eda2"], 1, "Second-generation ALMO-EDA."),
+            ("almo_eda_frozen", BIBTEX["frozen"], 2, "The frozen-term decomposition."),
+            ("ferf", BIBTEX["ferf"], 2, "Polarization from FERFs."),
+        ]

interaction_eda_step/data/configuration.txt

@@ -0,0 +1,3 @@
+[interaction-eda-step]
+# The Interaction EDA step has no options here yet. How GPU4PySCF is run is in
+# gpu4pyscf.ini in the SEAMM installation's directory.

interaction_eda_step/data/gpu4pyscf.ini

@@ -0,0 +1,33 @@
+# How to run GPU4PySCF for the Interaction EDA step.
+#
+# GPU4PySCF lives in its own Python environment (GPU4PySCF 1.9.1 or later, with
+# CuPy, cuTENSOR and pyscf-dispersion) and needs Linux and an NVIDIA GPU with good
+# double precision: A100, A30, H100/H200 or B200, not L40S or T4.
+#
+# Each section is for one executor ('local' runs on this machine).
+
+[local]
+# The type of installation. Options are:
+#     conda: the Conda environment below, which interaction-eda-step-installer
+#            creates and fills (the default)
+#     local: 'code' is the full path to the Python of an environment you made
+
+installation = conda
+
+# For a conda installation, the conda executable and the environment.
+
+# conda = /path/to/conda
+conda-environment = seamm-gpu4pyscf
+
+# The Python that runs the step's driver script: 'python' in the Conda
+# environment, or e.g. /home/me/envs/gpu4pyscf/bin/python for a local one.
+
+code = python
+
+# Which CUDA build of GPU4PySCF the installer puts in the environment. 'auto'
+# reads the NVIDIA driver with nvidia-smi and uses the CUDA 12 build (the
+# validated one, which also runs with CUDA 13 drivers); with no driver, as on a
+# cluster login node, it also uses the CUDA 12 build. Set cuda12x or cuda13x to
+# force one.
+
+cuda-build = auto

interaction_eda_step/data/gpu4pyscf_eda.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python
+"""Second-generation ALMO-EDA with GPU4PySCF, for SEAMM's Interaction EDA step.
+
+Runs in the GPU4PySCF environment, which needs nothing from SEAMM:
+
+    python gpu4pyscf_eda.py input.json [-o results.jsonl]
+
+``input.json``::
+
+    {"settings": {"xc": "wb97m-v", "basis": "def2-tzvpd", "auxbasis": null,
+                  "nlc": null, "disp": null, "svd_threshold": null,
+                  "ferf": "coupled", "response_nlc": true, "verbose": 3},
+     "calculations": [{"id": "0+1",
+                       "fragments": [{"label": "0:Li+", "symbols": ["Li"],
+                                      "coordinates": [[0.0, 0.0, 0.0]],
+                                      "charge": 1, "spin": 0}, ...]}, ...]}
+
+``nlc: false`` removes VV10 from the whole functional; ``response_nlc: false``
+removes it only from the FERF response kernel (the SCF and SCF-MI keep it).
+Coordinates are in Å. Each calculation appends one JSON line to the results file:
+the ALMO-EDA terms in kJ/mol, the energies in hartree, the wall time, the peak GPU
+memory and the versions -- or the error. Calculations already in the results file
+are skipped, so a job that ran out of time can simply be run again.
+
+The GPU needs good double-precision throughput (A100, A30, H100/H200, B200).
+"""
+
+import argparse
+import functools
+import json
+import os
+import re
+import sys
+import threading
+import time
+import traceback
+
+# GPUs made for single precision: FP64 at 1/32-1/64 of FP32 (whole words, so
+# that "A10" does not match "A100").
+LOW_FP64 = re.compile(r"\b(T4|L4|L40S?|A10|A16|A40|RTX|GEFORCE)\b", re.IGNORECASE)
+
+
+def low_fp64(gpu):
+    """Whether the GPU, by name, has little double-precision throughput."""
+    return LOW_FP64.search(gpu) is not None
+
+
+def gpu_refusal(gpu, settings):
+    """Why the calculations must not run on this GPU, or None if they may.
+
+    A GPU made for single precision runs ALMO-EDA tens of times slower than one
+    with full double precision, so the step refuses it unless told to allow it.
+    """
+    if not low_fp64(gpu) or settings.get("allow_low_fp64", False):
+        return None
+    return (
+        f"The {gpu} has little double-precision (FP64) throughput, so the EDA "
+        "would be very slow: nothing was run. Use a queue with A100, A30, "
+        "H100/H200, B200 or V100 GPUs, or set 'GPUs with little FP64' to 'allow'."
+    )
+
+
+class PeakGPUMemory:
+    """Sample the device's used memory (all processes on it) in a thread."""
+
+    def __init__(self, cp, interval=0.1):
+        self.cp = cp
+        self.interval = interval
+        self.peak = 0
+        self._stop = threading.Event()
+
+    def _run(self):
+        while not self._stop.is_set():
+            free, total = self.cp.cuda.runtime.memGetInfo()
+            self.peak = max(self.peak, total - free)
+            time.sleep(self.interval)
+
+    def __enter__(self):
+        self.base = self.cp.cuda.runtime.memGetInfo()
+        self.thread = threading.Thread(target=self._run, daemon=True)
+        self.thread.start()
+        return self
+
+    def __exit__(self, *args):
+        self._stop.set()
+        self.thread.join()
+
+
+def done_ids(path):
+    ids = set()
+    if os.path.exists(path):
+        with open(path) as fd:
+            for line in fd:
+                try:
+                    record = json.loads(line)
+                except ValueError:
+                    continue
+                if "eda_kJ_mol" in record:
+                    ids.add(record["id"])
+    return ids
+
+
+def versions():
+    out = {"python": sys.version.split()[0]}
+    for name in ("gpu4pyscf", "pyscf", "cupy"):
+        try:
+            module = __import__(name)
+            out[name] = getattr(module, "__version__", "?")
+        except Exception:  # pragma: no cover
+            out[name] = None
+    return out
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    p.add_argument("input")
+    p.add_argument("-o", "--output", default="results.jsonl")
+    p.add_argument("--logdir", default="logs")
+    args = p.parse_args(argv)
+
+    with open(args.input) as fd:
+        data = json.load(fd)
+    settings = data.get("settings", {})
+    calculations = data["calculations"]
+
+    import cupy as cp
+    import pyscf
+    import gpu4pyscf.properties.eda as eda_module
+
+    ferf_options = {}
+    if settings.get("svd_threshold") is not None:
+        ferf_options["virtual_singular_value_threshold"] = float(
+            settings["svd_threshold"]
+        )
+    if settings.get("ferf", "coupled") == "uncoupled":
+        ferf_options["uncoupled_ferf"] = True
+    if ferf_options:
+        eda_module._get_eda_polarization_FERF_subspace_projector = functools.partial(
+            eda_module._get_eda_polarization_FERF_subspace_projector, **ferf_options
+        )
+
+    if not settings.get("response_nlc", True):
+        # VV10 off in the FERF response kernel only; the SCF and SCF-MI keep the
+        # full functional (the Psi4-parity mode). eda.py looks gen_vind up at
+        # call time, so rebinding the module attribute is enough.
+        import gpu4pyscf.properties.polarizability as polarizability
+
+        _gen_vind = polarizability.gen_vind
+
+        def gen_vind_no_nlc(mf, mo_coeff, mo_occ, with_nlc=True):
+            return _gen_vind(mf, mo_coeff, mo_occ, with_nlc=False)
+
+        polarizability.gen_vind = gen_vind_no_nlc
+
+    nlc = settings.get("nlc")
+    if isinstance(nlc, str) and nlc.lower() in ("false", "no", "none", "off", "0", ""):
+        nlc = False
+    xc = settings.get("xc", "wb97m-v")
+    basis = settings.get("basis", "def2-tzvpd")
+    auxbasis = settings.get("auxbasis")
+    disp = settings.get("disp")
+    verbose = int(settings.get("verbose", 3))
+
+    gpu = cp.cuda.runtime.getDeviceProperties(0)["name"]
+    gpu = gpu.decode() if isinstance(gpu, bytes) else str(gpu)
+    info = versions()
+    print(f"GPU: {gpu}; {info}", flush=True)
+    refusal = gpu_refusal(gpu, settings)
+    if refusal is not None:
+        print(f"REFUSED: {refusal}", file=sys.stderr, flush=True)
+        return 3
+    if low_fp64(gpu):
+        print(
+            f"WARNING: the {gpu} has little double-precision (FP64) throughput, so "
+            "this will be very slow ('GPUs with little FP64' is 'allow').",
+            flush=True,
+        )
+    os.makedirs(args.logdir, exist_ok=True)
+    skip = done_ids(args.output)
+
+    n_failed = 0
+    with open(args.output, "a") as out:
+        for calc in calculations:
+            cid = calc["id"]
+            if cid in skip:
+                print(f"{cid}: already done", flush=True)
+                continue
+            log = os.path.join(args.logdir, f"{cid}.log")
+            with open(log, "w") as logfd:
+                record = {"id": cid, "gpu": gpu, "versions": info}
+                t0 = time.time()
+                try:
+                    mols = []
+                    for frag in calc["fragments"]:
+                        geom = "\n".join(
+                            "{} {:.10f} {:.10f} {:.10f}".format(s, *xyz)
+                            for s, xyz in zip(frag["symbols"], frag["coordinates"])
+                        )
+                        m = pyscf.M(
+                            atom=geom,
+                            basis=basis,
+                            charge=int(frag.get("charge", 0)),
+                            spin=int(frag.get("spin", 0)),
+                            verbose=0,
+                        )
+                        m.stdout = logfd  # one log for all fragments
+                        m.verbose = verbose
+                        mols.append(m)
+                    cp.get_default_memory_pool().free_all_blocks()
+                    with PeakGPUMemory(cp) as mem:
+                        eda, dft = eda_module.eval_ALMO_EDA_2_energies(
+                            mols,
+                            xc=xc,
+                            auxbasis=auxbasis,
+                            verbose=verbose,
+                            nlc=nlc,
+                            disp=disp,
+                        )
+                    cp.cuda.runtime.deviceSynchronize()
+                    record["eda_kJ_mol"] = {
+                        k: float(v) for k, v in eda.items() if k != "unit"
+                    }
+                    record["energies_hartree"] = _plain(dft.get("energy"))
+                    record["nao"] = int(sum(m.nao for m in mols))
+                    record["peak_gpu_mem_GB"] = round(mem.peak / 1e9, 3)
+                except Exception:
+                    n_failed += 1
+                    record["error"] = traceback.format_exc()
+                    print(f"{cid}: FAILED\n{record['error']}", flush=True)
+                record["wall_s"] = round(time.time() - t0, 2)
+            out.write(json.dumps(record) + "\n")
+            out.flush()
+            if "eda_kJ_mol" in record:
+                e = record["eda_kJ_mol"]
+                print(
+                    f"{cid}: total {e['total']:.3f} kJ/mol ({record['wall_s']} s, "
+                    f"{record['peak_gpu_mem_GB']} GB)",
+                    flush=True,
+                )
+    return 1 if n_failed else 0
+
+
+def _plain(value):
+    """JSON-safe copy of numbers, lists and dicts (numpy/cupy scalars too)."""
+    if isinstance(value, dict):
+        return {str(k): _plain(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_plain(v) for v in value]
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return str(value)
+
+
+if __name__ == "__main__":
+    sys.exit(main())