Source code for psi4.extras

# Psi4: an open-source quantum chemistry software package
# Copyright (c) 2007-2022 The Psi4 Developers.
# The copyrights for code used from other parties are included in
# the corresponding files.
# This file is part of Psi4.
# Psi4 is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, version 3.
# Psi4 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# GNU Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public License along
# with Psi4; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

import atexit
import datetime
import itertools
import os
from typing import List, Union
from pathlib import Path

from qcelemental.util import which, which_import

from . import core

# Numpy place holder for files and cleanup
numpy_files = []

def register_numpy_file(filename):
    if not filename.endswith('.npy'): filename += '.npy'
    if filename not in numpy_files:

def clean_numpy_files():
    for nfile in numpy_files:
        except OSError:


def exit_printing(start_time: datetime.datetime = None, success: bool = None) -> None:
    """Prints the exit time and status.

         starting time from which the elapsed time is computed.
        Provides a success flag, otherwise uses the ``_success_flag_`` global variable


    end_time =
    core.print_out("\n    Psi4 stopped on: {}".format(end_time.strftime('%A, %d %B %Y %I:%M%p')))
    if start_time is not None:
        run_time = end_time - start_time
        run_time = str(run_time).split('.')
        run_time = run_time[0] + '.' + run_time[1][:2]
        core.print_out("\n    Psi4 wall time for execution: {}\n".format(run_time))

    if success is None:
        success = _success_flag_

    if success:
        core.print_out("\n*** Psi4 exiting successfully. Buy a developer a beer!\n")
        core.print_out("\n*** Psi4 encountered an error. Buy a developer more coffee!\n")
        core.print_out("*** Resources and help at\n")

_success_flag_ = False

# Working directory
_input_dir_ = os.getcwd()

def get_input_directory():
    return _input_dir_

# Add-Ons
def _CMake_to_Py_boolean(cmakevar):
    if cmakevar.upper() in ["1", "ON", "YES", "TRUE", "Y"]:
        return True
        return False

def psi4_which(command, *, return_bool: bool = False, raise_error: bool = False,
               raise_msg: str = None) -> Union[bool, None, str]:
    """Test to see if a command is available in Psi4 search path.

    str or None
        By default, returns command path if command found or `None` if not.
        Environment is $PSIPATH:$PATH, less any None values.
        When `return_bool=True`, returns whether or not found.

        When `raises_error=True` and command not found.

    lenv = (os.pathsep.join([os.path.abspath(x) for x in os.environ.get('PSIPATH', '').split(os.pathsep) if x != '']) +
            os.pathsep + os.environ.get('PATH', ''))

    return which(command=command, return_bool=return_bool, raise_error=raise_error, raise_msg=raise_msg, env=lenv)

_addons_ = {
    "adcc": which_import("adcc", return_bool=True),
    "ambit": _CMake_to_Py_boolean("OFF"),
    "chemps2": _CMake_to_Py_boolean("OFF"),
    "dkh": _CMake_to_Py_boolean("OFF"),
    "ecpint": _CMake_to_Py_boolean("ON"),
    "libefp": which_import("pylibefp", return_bool=True),
    "erd": _CMake_to_Py_boolean("OFF"),
    "gdma": _CMake_to_Py_boolean("OFF"),
    "ipi": which_import("ipi", return_bool=True),
    "pcmsolver": _CMake_to_Py_boolean("OFF"),
    "cppe": which_import("cppe", return_bool=True),
    "ddx": which_import("pyddx", return_bool=True),
    "simint": _CMake_to_Py_boolean("OFF"),
    "dftd3": psi4_which("dftd3", return_bool=True),
    "cfour": psi4_which("xcfour", return_bool=True),
    "mrcc": psi4_which("dmrcc", return_bool=True),
    "gcp": psi4_which("gcp", return_bool=True),
    "v2rdm_casscf": which_import("v2rdm_casscf", return_bool=True),
    "gpu_dfcc": which_import("gpu_dfcc", return_bool=True),
    "forte": which_import("forte", return_bool=True),
    "snsmp2": which_import("snsmp2", return_bool=True),
    "resp": which_import("resp", return_bool=True),
    "psi4fockci": which_import("psi4fockci", return_bool=True),
    "adcc": which_import("adcc", return_bool=True),
    "mdi": which_import("mdi", return_bool=True),
    "cct3": which_import("cct3", return_bool=True),
    "dftd4": which_import("dftd4", return_bool=True),
    "mp2d": psi4_which("mp2d", return_bool=True),
    "openfermionpsi4": which_import("openfermionpsi4", return_bool=True),
    "geometric": which_import("geometric", return_bool=True),
    #"optking": which_import("optking", return_bool=True),
    "psixas": which_import("psixas", return_bool=True),
    #"mctc-gcp": psi4_which("mctc-gcp", return_bool=True),

def addons(request: str = None) -> Union[bool, List[str]]:
    """Returns boolean of whether Add-On *request* is available to Psi4,
    either compiled in or searchable in $PSIPATH:$PATH, as relevant. If
    *request* not passed, returns list of available Add-Ons: `['adcc', 'ambit', 'c̶c̶t̶3̶', ...` .

    def strike(text):
        return ''.join(itertools.chain.from_iterable(zip(text, itertools.repeat('\u0336'))))

    if request is None:
        return [(k if v else strike(k)) for k, v in sorted(_addons_.items())]
    return _addons_[request.lower()]

# Testing
def test(extent: str = "full", extras: List = None) -> int:
    """Runs a test suite through pytest.

        {'smoke', 'quick', 'full', 'long'}
        All choices are defined, but choices may be redundant in some projects.

          * _smoke_ will be minimal "is-working?" test(s).
          * _quick_ will be as much coverage as can be got quickly, approx. 1/3 tests.
          * _full_ will be the whole test suite, less some exceedingly long outliers.
          * _long_ will be the whole test suite.
        Additional arguments to pass to `pytest`.

        Return code from `pytest.main()`. 0 for pass, 1 for fail.

        import pytest
    except ImportError:
        raise RuntimeError('Testing module `pytest` is not installed. Run `conda install pytest`')
    abs_test_dir = os.path.sep.join([os.path.abspath(os.path.dirname(__file__)), "tests"])

    command = ['-rws', '-v']
    if extent.lower() == 'smoke':
        command.extend(['-m', 'smoke'])
    elif extent.lower() == 'quick':
        command.extend(['-m', 'quick or smoke'])
    elif extent.lower() == 'full':
        command.extend(['-m', 'not long'])
    elif extent.lower() == 'long':
    if extras is not None:
    command.extend(['--capture=sys', abs_test_dir])

    retcode = pytest.main(command)
    return retcode

[docs]def set_output_file(ofile: str, append: bool = False, *, loglevel: int = 20, execute: bool = True) -> Path: """Set the name for output and logging files. Parameters ---------- ofile Name of ASCII output file including extension. The logging file is set from this string with a ``.log`` extension. append Do append to the output and logging files rather than (the default) truncating them? loglevel The criticality level at which to log. 30 for WARN (Python default), 20 for INFO, 10 for DEBUG execute Do set ``ofile`` via :py:func:`psi4.core.set_output_file` and add the logger, rather than just returning ``ofile`` path. Returns ------- ~pathlib.Path ``Path(ofile)`` Notes ----- This :py:func:`psi4.set_output_file` command calls :py:func:`psi4.core.set_output_file` and should be used in preference to it as this additionally sets up logging. """ out = Path(ofile) log = out.with_suffix(".log") # Get the custom logger import logging from psi4 import logger logger.setLevel(loglevel) # Create formatters # * detailed: example: 2019-11-20:01:13:46,811 DEBUG [psi4.driver.task_base:156] f_format_detailed = logging.Formatter("%(asctime)s,%(msecs)d %(levelname)-8s [%(name)s:%(lineno)d] %(message)s", datefmt="%Y-%m-%d:%H:%M:%S") # * light: example: 2019-11-20:10:45:21 FINDIFREC CLASS INIT DATA f_format_light = logging.Formatter("%(asctime)s %(message)s", datefmt="%Y-%m-%d:%H:%M:%S") # Create handlers, add formatters to handlers, and add handlers to logger (StreamHandler() also available) filemode = "a" if append else "w" f_handler = logging.FileHandler(log, filemode) f_handler.setLevel(logging.DEBUG) f_handler.setFormatter(f_format_detailed) if execute: core.set_output_file(str(out), append) # Warning: baseFilename is not part of the documented API for the logging module and could change. filenames = [handle.baseFilename for handle in logger.handlers] if not f_handler.baseFilename in filenames: logger.addHandler(f_handler) return out