"""Build MODFLOW-based models and other utility software.
Targets are defined in the usgsprograms database (usgsprograms.toml), which can
be queried using functions in the usgsprograms module. An example of using
:code:`pymake.build_apps()` to build MODFLOW 6 is:
.. code-block:: python
import pymake
pymake.build_apps(["mf6",])
which will download the latest MODFLOW 6 software release, compile the code,
and delete the downloaded files after successfully building the application.
Multiple applications can be built by adding additional targets to the tuple
in :code:`pymake.build_apps()`. For example, MODFLOW 6 and MODFLOW-2005 could
be built by specifying:
.. code-block:: python
import pymake
pymake.build_apps(["mf6","mf2005"]))
Applications are built in the order they are listed in the list. All valid
USGS applications are built if no list is passed to
:code:`pymake.build_apps()`.
"""
import shutil
import sys
from datetime import datetime
from pathlib import Path
from .pymake import Pymake
from .pymake_base import get_temporary_directories
from .utils._compiler_switches import (
_get_base_compiler_name,
_replace_base_compiler_name,
)
from .utils.usgsprograms import usgs_program_data
[docs]
def build_apps(
targets=None,
pymake_object=None,
download_dir=None,
appdir=None,
verbose=None,
double=False,
mesondir=None,
exclude=None,
clean=True,
):
"""Build all of the current targets or a subset of targets.
Parameters
----------
targets : str or list of str
targets to build. If targets is None, all current targets will
be built. Default is None
pymake_object : Pymake()
Pymake object created outside of build_apps
download_dir : str
download directory path
appdir : str
target path
double : bool
force double precision. (default is False)
mesondir : str
Main meson.build file path. the directory a target is downloaded to
is used when mesondir is None (default is None)
exclude : str or list of str
list of targets to exclude from build
clean : bool
boolean determining of final download should be removed
Returns
-------
returncode : int
integer value indicating successful completion (0) or failure (>0)
"""
start_time = datetime.now()
# intercept all string (":") from make-program
if isinstance(targets, str):
if targets == ":":
targets = None
# set targets
if targets is None:
targets = usgs_program_data.get_keys(current=True)
else:
if isinstance(targets, str):
targets = targets.split(",")
# exclude targets
if exclude is not None:
if isinstance(exclude, str):
exclude = exclude.split(",")
targets = [t for t in targets if t not in exclude]
code_dict = {}
if pymake_object is None:
pmobj = Pymake()
else:
if isinstance(pymake_object, Pymake):
pmobj = pymake_object
else:
msg = (
f"pymake_object ({type(pymake_object)}) is not of type {type(Pymake())}"
)
raise TypeError(msg)
# set base path for temporary directories
if appdir is None:
base_pth = "."
else:
base_pth = str(Path(appdir).parent)
# set the meson directory if a pymake object was not passed in
if pymake_object is None:
pmobj.mesondir = mesondir
elif pmobj.mesondir != mesondir:
pmobj.mesondir = mesondir
# clean any existing temporary directories
temp_pths = get_temporary_directories(base_pth)
for pth in temp_pths:
if Path(pth).is_dir():
shutil.rmtree(pth)
# set object to clean after each build
pmobj.makeclean = clean
# reset variables based on passed args
if download_dir is not None:
pmobj.download_dir = download_dir
if appdir is not None:
pmobj.appdir = appdir
if verbose is not None:
pmobj.verbose = verbose
for idt, target in enumerate(targets):
start_downcomp = datetime.now()
code_dict[target] = usgs_program_data.get_target(target)
# write system information
if idt == 0:
if pmobj.verbose:
print(
f"{target} will be built "
f'for the "{sys.platform}" operating system\n'
)
# save initial compiler settings
if idt == 0:
fc0 = pmobj.fc
cc0 = pmobj.cc
fflags0 = pmobj.fflags
cflags0 = pmobj.cflags
syslibs0 = pmobj.syslibs
# reset fortran, c/c++, and syslib flags
else:
pmobj.fflags = fflags0
pmobj.cflags = cflags0
pmobj.syslibs = syslibs0
# reset compilers
if target in ("gridgen",):
pmobj.fc = "none"
if _get_base_compiler_name(pmobj.cc) in ("gcc",):
pmobj.cc = _replace_base_compiler_name(pmobj.cc, "g++")
elif _get_base_compiler_name(pmobj.cc) in ("clang",):
pmobj.cc = _replace_base_compiler_name(pmobj.cc, "clang++")
elif target in ("triangle",):
pmobj.fc = "none"
elif target in ("mf6", "libmf6"):
pmobj.cc = "none"
else:
pmobj.fc = fc0
pmobj.cc = cc0
# set sharedobject
if target in ("libmf6",):
pmobj.sharedobject = True
else:
pmobj.sharedobject = False
# reset srcdir2 - TODO make more robust
if target not in ("libmf6",):
pmobj.srcdir2 = None
# reset extrafiles for instances with more than one target
if idt > 0:
pmobj.extrafiles = None
# set double precision flag and whether the executable name
# can be modified
if target in ("swtv4",):
update_target_name = False
else:
update_target_name = True
# set download information
if download_dir is None:
download_dir = "temp"
download_verify = True
timeout = 30
# set target and srcdir
pmobj.target = target.replace("dev", "")
pmobj.srcdir = str(
Path(download_dir) / code_dict[target].dirname / code_dict[target].srcdir
)
# determine if single, double, or both should be built
prog_precision = usgs_program_data.get_precision(target)
# just build the first precision in precision list if
# reset prog_precision if double
if double:
prog_precision = ["double"]
for precision_str in prog_precision:
# set double flag
if precision_str == "double":
pmobj.double = True
else:
pmobj.double = False
# determine if the target should be built
build_target = pmobj.set_build_target_bool(
target=pmobj.update_target(target, modify_target=update_target_name)
)
# setup download for target
pmobj.download_setup(
target,
download_path=download_dir,
verify=download_verify,
timeout=timeout,
)
# build the code
if build_target:
pmobj.build(modify_exe_name=update_target_name)
# add target to build_targets list, if necessary
else:
pmobj.update_build_targets()
# calculate download and compile time
end_downcomp = datetime.now()
elapsed = end_downcomp - start_downcomp
if pmobj.verbose:
print("elapsed download and compile time (hh:mm:ss.ms): " + f"{elapsed}\n")
end_time = datetime.now()
elapsed = end_time - start_time
if pmobj.verbose:
print(f"elapsed time (hh:mm:ss.ms): {elapsed}\n")
# compress targets
if pmobj.returncode == 0:
pmobj.compress_targets()
# execute final Pymake object operations
if clean:
pmobj.finalize()
return pmobj.returncode