Use cmdstan config and decouple stanfit objects from RunSet

cmdstanpy/__init__.py

@@ -32,7 +32,7 @@ def _cleanup_tmpdir() -> None:
     CmdStanMLE,
     CmdStanPathfinder,
     CmdStanVB,
-    from_csv,
+    from_output_files,
 )
 from .utils import (
     cmdstan_path,
@@ -60,7 +60,7 @@ def _cleanup_tmpdir() -> None:
     'CmdStanLaplace',
     'CmdStanPathfinder',
     'CmdStanModel',
-    'from_csv',
+    'from_output_files',
     'write_stan_json',
     'show_versions',
     'rebuild_cmdstan',

cmdstanpy/model.py

@@ -22,7 +22,6 @@
     CmdStanArgs,
     GenerateQuantitiesArgs,
     LaplaceArgs,
-    Method,
     OptimizeArgs,
     PathfinderArgs,
     SamplerArgs,
@@ -37,8 +36,9 @@
     CmdStanVB,
     PrevFit,
     RunSet,
-    from_csv,
+    from_output_files,
 )
+from cmdstanpy.stanfit.base import SingleFileFit
 from cmdstanpy.utils import do_command, get_logger
 from cmdstanpy.utils.cmdstan import cmdstan_version_before, windows_tbb_path
 from cmdstanpy.utils.filesystem import (
@@ -175,12 +175,6 @@ def __init__(
                 user_header=user_header,
             )
 
-            # try to detect models w/out parameters, needed for sampler
-            if cmdstan_version_before(2, 36):
-                model_info = self.src_info()
-                if 'parameters' in model_info:
-                    self._fixed_param |= len(model_info['parameters']) == 0
-
         # check CmdStan version compatibility
         exe_info = None
         try:
@@ -192,9 +186,9 @@ def __init__(
                 self._name,
                 str(e),
             )
-        if cmdstan_version_before(2, 35, exe_info):
+        if cmdstan_version_before(2, 37, exe_info):
             raise RuntimeError(
-                "This version of CmdStanPy requires CmdStan 2.35 or higher."
+                "This version of CmdStanPy requires CmdStan 2.37 or higher."
             )
 
     def __repr__(self) -> str:
@@ -434,16 +428,21 @@ def optimize(
             )
         runset.raise_for_timeouts()
 
-        if not runset._check_retcodes():
+        converged = runset._check_retcodes()
+        if not converged:
             msg = "Error during optimization! Command '{}' failed: {}".format(
                 ' '.join(runset.cmd(0)), runset.get_err_msgs()
             )
             if 'Line search failed' in msg and not require_converged:
                 get_logger().warning(msg)
             else:
                 raise RuntimeError(msg)
-        mle = CmdStanMLE(runset)
-        return mle
+        return CmdStanMLE.from_files(
+            csv_file=runset.csv_files[0],
+            config_file=runset.config_files[0],
+            stdout_file=runset.stdout_files[0],
+            converged=converged,
+        )
 
     # pylint: disable=too-many-arguments
     def sample(
@@ -530,16 +529,16 @@ def sample(
         :param parallel_chains: Number of processes to run in parallel. Must be
             a positive integer.  Defaults to :func:`multiprocessing.cpu_count`,
             i.e., it will only run as many chains in parallel as there are
-            cores on the machine.   Note that CmdStan 2.28 and higher can run
-            all chains in parallel providing that the model was compiled with
-            threading support.
+            cores on the machine.   Note that CmdStan can run all chains in
+            parallel providing that the model was compiled with threading
+            support.
 
         :param threads_per_chain: The number of threads to use in parallelized
             sections within an MCMC chain (e.g., when using the Stan functions
             ``reduce_sum()``  or ``map_rect()``).  This will only have an effect
             if the model was compiled with threading support.  For such models,
-            CmdStan version 2.28 and higher will run all chains in parallel
-            from within a single process.  The total number of threads used
+            CmdStan will run all chains in parallel from within a single
+            process.  The total number of threads used
             will be ``parallel_chains * threads_per_chain``, where the default
             value for parallel_chains is the number of cpus, not chains.
 
@@ -683,12 +682,12 @@ def sample(
 
         :param force_one_process_per_chain: If ``True``, run multiple chains in
             distinct processes regardless of model ability to run parallel
-            chains (CmdStan 2.28+ feature). If ``False``, always run multiple
-            chains in one process (does not check that this is valid).
+            chains. If ``False``, always run multiple chains in one process
+            (does not check that this is valid).
 
-            If None (Default): Check that CmdStan version is >=2.28, and that
-            model was compiled with STAN_THREADS=True, and utilize the
-            parallel chain functionality if those conditions are met.
+            If None (Default): Check that the model was compiled with
+            STAN_THREADS=True, and utilize the parallel chain functionality
+            if so.
 
         :param timeout: Duration at which sampling times out in seconds.
 
@@ -945,7 +944,16 @@ def sample(
                     )
                 get_logger().warning(msg)
 
-            mcmc = CmdStanMCMC(runset)
+            mcmc = CmdStanMCMC.from_files(
+                csv_files=runset.csv_files,
+                config_files=runset.config_files,
+                metric_files=runset.metric_files or None,
+                stdout_files=runset.stdout_files,
+                diagnostic_files=runset.diagnostic_files or None,
+                profile_files=runset.profile_files or None,
+                chain_ids=runset.chain_ids,
+                sig_figs=runset._args.sig_figs,
+            )
         return mcmc
 
     def generate_quantities(
@@ -1040,15 +1048,20 @@ def generate_quantities(
             ),
         ):
             fit_object = previous_fit
-            fit_csv_files = previous_fit.runset.csv_files
+            if isinstance(previous_fit, SingleFileFit):
+                fit_csv_files = [previous_fit.csv_file]
+            else:
+                fit_csv_files = previous_fit.csv_files
         elif isinstance(previous_fit, list):
             if len(previous_fit) < 1:
                 raise ValueError(
                     'Expecting list of Stan CSV files, found empty list'
                 )
             try:
                 fit_csv_files = previous_fit
-                fit_object: PrevFit = from_csv(fit_csv_files)  # type: ignore
+                fit_object: PrevFit = from_output_files(  # type: ignore
+                    fit_csv_files
+                )
             except ValueError as e:
                 raise ValueError(
                     'Invalid sample from Stan CSV files, error:\n\t{}\n\t'
@@ -1072,7 +1085,7 @@ def generate_quantities(
         elif isinstance(fit_object, CmdStanMLE):
             chains = 1
             chain_ids = [1]
-            if fit_object._save_iterations:
+            if fit_object.config.method_config.save_iterations:
                 get_logger().warning(
                     'MLE contains saved iterations which will be used '
                     'to generate additional quantities of interest.'
@@ -1126,7 +1139,13 @@ def generate_quantities(
                         ' above output is unclear!'
                     )
                 raise RuntimeError(msg)
-            quantities = CmdStanGQ(runset=runset, previous_fit=fit_object)
+            quantities = CmdStanGQ.from_files(
+                csv_files=runset.csv_files,
+                config_files=runset.config_files,
+                previous_fit=fit_object,
+                stdout_files=runset.stdout_files,
+                chain_ids=runset.chain_ids,
+            )
         return quantities
 
     def variational(
@@ -1329,9 +1348,11 @@ def variational(
                     runset.get_err_msgs()
                 )
             raise RuntimeError(msg)
-        # pylint: disable=invalid-name
-        vb = CmdStanVB(runset)
-        return vb
+        return CmdStanVB.from_files(
+            csv_file=runset.csv_files[0],
+            config_file=runset.config_files[0],
+            stdout_file=runset.stdout_files[0],
+        )
 
     def pathfinder(
         self,
@@ -1553,7 +1574,11 @@ def pathfinder(
                 ' '.join(runset.cmd(0)), runset.get_err_msgs()
             )
             raise RuntimeError(msg)
-        return CmdStanPathfinder(runset)
+        return CmdStanPathfinder.from_files(
+            csv_file=runset.csv_files[0],
+            config_file=runset.config_files[0],
+            stdout_file=runset.stdout_files[0],
+        )
 
     def log_prob(
         self,
@@ -1735,28 +1760,25 @@ def laplace_sample(
                     "Consider supplying a mode or additional optimizer args"
                 ) from e
         elif not isinstance(mode, CmdStanMLE):
-            cmdstan_mode = from_csv(mode)  # type: ignore  # we check below
+            # we check the type below
+            cmdstan_mode = from_output_files(mode)  # type: ignore
         else:
             cmdstan_mode = mode
 
-        if cmdstan_mode.runset.method != Method.OPTIMIZE:
+        if not isinstance(cmdstan_mode, CmdStanMLE):
             raise ValueError(
                 "Mode must be a CmdStanMLE or a path to an optimize CSV"
             )
 
-        mode_jacobian = (
-            cmdstan_mode.runset._args.method_args.jacobian  # type: ignore
-        )
+        mode_jacobian = cmdstan_mode.config.method_config.jacobian
         if mode_jacobian != jacobian:
             raise ValueError(
                 "Jacobian argument to optimize and laplace must match!\n"
                 f"Laplace was run with jacobian={jacobian},\n"
                 f"but optimize was run with jacobian={mode_jacobian}"
             )
 
-        laplace_args = LaplaceArgs(
-            cmdstan_mode.runset.csv_files[0], draws, jacobian
-        )
+        laplace_args = LaplaceArgs(cmdstan_mode.csv_file, draws, jacobian)
 
         with temp_single_json(data) as _data:
             args = CmdStanArgs(
@@ -1780,7 +1802,12 @@ def laplace_sample(
                 timeout=timeout,
             )
         runset.raise_for_timeouts()
-        return CmdStanLaplace(runset, cmdstan_mode)
+        return CmdStanLaplace.from_files(
+            csv_file=runset.csv_files[0],
+            config_file=runset.config_files[0],
+            stdout_file=runset.stdout_files[0],
+            mode=cmdstan_mode,
+        )
 
     def _run_cmdstan(
         self,