cmdstanpy 1.3.1__tar.gz → 1.3.2__tar.gz

{cmdstanpy-1.3.1/cmdstanpy.egg-info → cmdstanpy-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmdstanpy
-Version: 1.3.1
+Version: 1.3.2
 Summary: Python interface to CmdStan
 Author: Stan Dev Team
 License: BSD-3-Clause

cmdstanpy-1.3.2/cmdstanpy/_version.py

@@ -0,0 +1,3 @@
+"""PyPi Version"""
+
+__version__ = '1.3.2'

{cmdstanpy-1.3.1 → cmdstanpy-1.3.2}/cmdstanpy/cmdstan_args.py

@@ -632,7 +632,7 @@ class CmdStanArgs:
     def __init__(
         self,
         model_name: str,
-        model_exe: str,
+        model_exe: OptionalPath,
         chain_ids: Optional[list[int]],
         method_args: Union[
             SamplerArgs,
@@ -692,6 +692,10 @@ class CmdStanArgs:
         * if no seed specified, set random seed.
         * length of per-chain lists equals specified # of chains
         """
+        if self.model_name is None:
+            raise ValueError('no stan model specified')
+        if self.model_exe is None:
+            raise ValueError('model not compiled')
 
         if self.chain_ids is not None:
             for chain_id in self.chain_ids:
@@ -853,10 +857,10 @@ class CmdStanArgs:
                         idx, len(self.chain_ids)
                     )
                 )
-            cmd.append(self.model_exe)
+            cmd.append(self.model_exe)  # type: ignore # guaranteed by validate
             cmd.append(f'id={self.chain_ids[idx]}')
         else:
-            cmd.append(self.model_exe)
+            cmd.append(self.model_exe)  # type: ignore # guaranteed by validate
 
         if self.seed is not None:
             if not isinstance(self.seed, list):

{cmdstanpy-1.3.1 → cmdstanpy-1.3.2}/cmdstanpy/compilation.py

@@ -8,6 +8,7 @@ import os
 import platform
 import shutil
 import subprocess
+from copy import copy
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Iterable, Optional, Union
@@ -36,6 +37,12 @@ STANC_OPTS = [
     'warn-pedantic',
 ]
 
+# TODO(2.0): remove
+STANC_DEPRECATED_OPTS = {
+    'allow_undefined': 'allow-undefined',
+    'include_paths': 'include-paths',
+}
+
 STANC_IGNORE_OPTS = [
     'debug-lex',
     'debug-parse',
@@ -60,6 +67,7 @@ STANC_IGNORE_OPTS = [
 OptionalPath = Union[str, os.PathLike, None]
 
 
+# TODO(2.0): can remove add function and other logic
 class CompilerOptions:
     """
     User-specified flags for stanc and C++ compiler.
@@ -87,6 +95,26 @@ class CompilerOptions:
             self._stanc_options, self._cpp_options
         )
 
+    def __eq__(self, other: Any) -> bool:
+        """Overrides the default implementation"""
+        if self.is_empty() and other is None:  # equiv w/r/t compiler
+            return True
+        if not isinstance(other, CompilerOptions):
+            return False
+        return (
+            self._stanc_options == other.stanc_options
+            and self._cpp_options == other.cpp_options
+            and self._user_header == other.user_header
+        )
+
+    def is_empty(self) -> bool:
+        """True if no options specified."""
+        return (
+            self._stanc_options == {}
+            and self._cpp_options == {}
+            and self._user_header == ''
+        )
+
     @property
     def stanc_options(self) -> dict[str, Union[bool, int, str, Iterable[str]]]:
         """Stanc compiler options."""
@@ -116,12 +144,31 @@ class CompilerOptions:
         Check stanc compiler args and consistency between stanc and C++ options.
         Raise ValueError if bad config is found.
         """
+        # pylint: disable=no-member
         if self._stanc_options is None:
             return
         ignore = []
         paths = None
         has_o_flag = False
 
+        for deprecated, replacement in STANC_DEPRECATED_OPTS.items():
+            if deprecated in self._stanc_options:
+                if replacement:
+                    get_logger().warning(
+                        'compiler option "%s" is deprecated, use "%s" instead',
+                        deprecated,
+                        replacement,
+                    )
+                    self._stanc_options[replacement] = copy(
+                        self._stanc_options[deprecated]
+                    )
+                    del self._stanc_options[deprecated]
+                else:
+                    get_logger().warning(
+                        'compiler option "%s" is deprecated and should '
+                        'not be used',
+                        deprecated,
+                    )
         for key, val in self._stanc_options.items():
             if key in STANC_IGNORE_OPTS:
                 get_logger().info('ignoring compiler option: %s', key)
@@ -220,6 +267,37 @@ class CompilerOptions:
 
             self._cpp_options['USER_HEADER'] = self._user_header
 
+    def add(self, new_opts: "CompilerOptions") -> None:  # noqa: disable=Q000
+        """Adds options to existing set of compiler options."""
+        if new_opts.stanc_options is not None:
+            if self._stanc_options is None:
+                self._stanc_options = new_opts.stanc_options
+            else:
+                for key, val in new_opts.stanc_options.items():
+                    if key == 'include-paths':
+                        if isinstance(val, Iterable) and not isinstance(
+                            val, str
+                        ):
+                            for path in val:
+                                self.add_include_path(str(path))
+                        else:
+                            self.add_include_path(str(val))
+                    else:
+                        self._stanc_options[key] = val
+        if new_opts.cpp_options is not None:
+            for key, val in new_opts.cpp_options.items():
+                self._cpp_options[key] = val
+        if new_opts._user_header != '' and self._user_header == '':
+            self._user_header = new_opts._user_header
+
+    def add_include_path(self, path: str) -> None:
+        """Adds include path to existing set of compiler options."""
+        path = os.path.abspath(os.path.expanduser(path))
+        if 'include-paths' not in self._stanc_options:
+            self._stanc_options['include-paths'] = [path]
+        elif path not in self._stanc_options['include-paths']:
+            self._stanc_options['include-paths'].append(path)
+
     def compose_stanc(self, filename_in_msg: Optional[str]) -> list[str]:
         opts = []
 
@@ -265,8 +343,7 @@ class CompilerOptions:
 
 
 def src_info(
-    stan_file: str,
-    stanc_options: Optional[dict[str, Any]] = None,
+    stan_file: str, compiler_options: CompilerOptions
 ) -> dict[str, Any]:
     """
     Get source info for Stan program file.
@@ -277,7 +354,7 @@ def src_info(
     cmd = (
         [stanc_path()]
         # handle include-paths, allow-undefined etc
-        + CompilerOptions(stanc_options=stanc_options).compose_stanc(None)
+        + compiler_options.compose_stanc(None)
         + ['--info', str(stan_file)]
     )
     proc = subprocess.run(cmd, capture_output=True, text=True, check=False)
@@ -330,26 +407,12 @@ def compile_stan_file(
     )
     compiler_options.validate()
 
-    # if program has include directives, record path
-    if '#include' in src.read_text():
-        path = os.fspath(src.parent.resolve())
-        if 'include-paths' not in compiler_options.stanc_options:
-            compiler_options.stanc_options['include-paths'] = [path]
-        else:
-            paths: list[str] = compiler_options.stanc_options[
-                'include-paths'
-            ]  # type: ignore
-            if path not in paths:
-                paths.append(path)
-
     exe_target = src.with_suffix(EXTENSION)
     if exe_target.exists():
         exe_time = os.path.getmtime(exe_target)
         included_files = [src]
         included_files.extend(
-            src_info(str(src), compiler_options.stanc_options).get(
-                'included_files', []
-            )
+            src_info(str(src), compiler_options).get('included_files', [])
         )
         out_of_date = any(
             os.path.getmtime(included_file) > exe_time
@@ -419,7 +482,7 @@ def compile_stan_file(
             raise ValueError(
                 f"Failed to compile Stan model '{src}'. Console:\n{console}"
             )
-        return os.fspath(exe_target)
+        return str(exe_target)
 
 
 def format_stan_file(

{cmdstanpy-1.3.1 → cmdstanpy-1.3.2}/cmdstanpy/model.py

@@ -13,7 +13,16 @@ from collections import OrderedDict
 from concurrent.futures import ThreadPoolExecutor
 from io import StringIO
 from multiprocessing import cpu_count
-from typing import Any, Callable, Iterable, Mapping, Optional, TypeVar, Union
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Literal,
+    Mapping,
+    Optional,
+    TypeVar,
+    Union,
+)
 
 import numpy as np
 import pandas as pd
@@ -69,6 +78,11 @@ class CmdStanModel:
     Stan program source file or the compiled executable, or both.
     This will compile the model if provided a Stan file and no executable,
 
+    :param model_name: Model name, used for output file names.
+        Optional, default is the base filename of the Stan program file.
+        Deprecated: In version 2.0.0, model name cannot be
+        specified and will always be taken from executable.
+
     :param stan_file: Path to Stan program file.
 
     :param exe_file: Path to compiled executable file.  Optional, unless
@@ -90,20 +104,31 @@ class CmdStanModel:
     :param user_header: A path to a header file to include during C++
         compilation.
         Optional.
+
+    :param compile: Whether or not to compile the model.  Default is ``True``.
+        If set to the string ``"force"``, it will always compile even if
+        an existing executable is found.
+        Deprecated: Use ``force_compile`` instead. The ability to instantiate
+        a CmdStanModel without an executable will be removed in version 2.0.0.
+
     """
 
     def __init__(
         self,
+        model_name: Optional[str] = None,
         stan_file: OptionalPath = None,
         exe_file: OptionalPath = None,
         force_compile: bool = False,
         stanc_options: Optional[dict[str, Any]] = None,
         cpp_options: Optional[dict[str, Any]] = None,
         user_header: OptionalPath = None,
+        *,
+        compile: Union[bool, Literal['force'], None] = None,
     ) -> None:
         """
         Initialize object given constructor args.
 
+        :param model_name: Deprecated. Model name, used for output file names.
         :param stan_file: Path to Stan program file.
         :param exe_file: Path to compiled executable file.
         :param force_compile: Whether or not to force recompilation if
@@ -112,19 +137,46 @@ class CmdStanModel:
         :param cpp_options: Options for C++ compiler.
         :param user_header: A path to a header file to include during C++
             compilation.
+        :param compile: Deprecated. Whether or not to compile the model.
         """
         self._name = ''
         self._stan_file = None
-        self._stanc_options: dict[str, Any] = stanc_options or {}
+        self._exe_file = None
+        self._compiler_options = compilation.CompilerOptions(
+            stanc_options=stanc_options,
+            cpp_options=cpp_options,
+            user_header=user_header,
+        )
+        self._compiler_options.validate()
 
         self._fixed_param = False
 
-        if exe_file is not None:
-            self._exe_file = os.path.realpath(os.path.expanduser(exe_file))
-            if not os.path.exists(self._exe_file):
-                raise ValueError('no such file {}'.format(self._exe_file))
-            _, exename = os.path.split(self._exe_file)
-            self._name, _ = os.path.splitext(exename)
+        if compile is None:
+            compile = True
+        else:
+            get_logger().warning(
+                "CmdStanModel(compile=...) is deprecated and will be "
+                "removed in the next major version. The constructor will "
+                "always ensure a model has a compiled executable.\n"
+                "If you wish to force recompilation, use force_compile=True "
+                "instead."
+            )
+
+        if force_compile:
+            compile = 'force'
+
+        if model_name is not None:
+            get_logger().warning(
+                "CmdStanModel(model_name=...) is deprecated and will be "
+                "removed in the next major version."
+            )
+            if not model_name.strip():
+                raise ValueError(
+                    'Invalid value for argument model name, found "{}"'.format(
+                        model_name
+                    )
+                )
+            self._name = model_name.strip()
 
         if stan_file is None:
             if exe_file is None:
@@ -132,11 +184,6 @@ class CmdStanModel:
                     'Missing model file arguments, you must specify '
                     'either Stan source or executable program file or both.'
                 )
-            if force_compile:
-                raise ValueError(
-                    'Cannot force compilation when no Stan source file '
-                    'is specified.'
-                )
         else:
             self._stan_file = os.path.realpath(os.path.expanduser(stan_file))
             if not os.path.exists(self._stan_file):
@@ -148,29 +195,41 @@ class CmdStanModel:
                 )
             if not self._name:
                 self._name, _ = os.path.splitext(filename)
-            else:
-                if self._name != os.path.splitext(filename)[0]:
-                    raise ValueError(
-                        'Name mismatch between Stan file and compiled'
-                        ' executable, expecting basename: {}'
-                        ' found: {}.'.format(self._name, filename)
-                    )
 
-            self._exe_file = compilation.compile_stan_file(
-                str(self.stan_file),
-                force=force_compile,
-                stanc_options=self._stanc_options,
-                cpp_options=cpp_options,
-                user_header=user_header,
-            )
+            # if program has include directives, record path
+            with open(self._stan_file, 'r') as fd:
+                program = fd.read()
+            if '#include' in program:
+                path, _ = os.path.split(self._stan_file)
+                self._compiler_options.add_include_path(path)
 
             # try to detect models w/out parameters, needed for sampler
             if (not cmdstan_version_before(2, 27)) and cmdstan_version_before(
                 2, 36
             ):
-                model_info = self.src_info()
-                if 'parameters' in model_info:
-                    self._fixed_param |= len(model_info['parameters']) == 0
+                try:
+                    model_info = self.src_info()
+                    if 'parameters' in model_info:
+                        self._fixed_param |= len(model_info['parameters']) == 0
+                except ValueError as e:
+                    if compile:
+                        raise
+                    get_logger().debug(e)
+
+        if exe_file is not None:
+            self._exe_file = os.path.realpath(os.path.expanduser(exe_file))
+            if not os.path.exists(self._exe_file):
+                raise ValueError('no such file {}'.format(self._exe_file))
+            _, exename = os.path.split(self._exe_file)
+            if not self._name:
+                self._name, _ = os.path.splitext(exename)
+            else:
+                if self._name != os.path.splitext(exename)[0]:
+                    raise ValueError(
+                        'Name mismatch between Stan file and compiled'
+                        ' executable, expecting basename: {}'
+                        ' found: {}.'.format(self._name, exename)
+                    )
 
         if platform.system() == 'Windows':
             try:
@@ -193,16 +252,22 @@ class CmdStanModel:
             else:
                 get_logger().debug("TBB already found in load path")
 
+        if compile and self._exe_file is None:
+            self.compile(force=str(compile).lower() == 'force', _internal=True)
+
     def __repr__(self) -> str:
-        return (
-            f"CmdStanModel(stan_file={self.stan_file!r}, "
-            f"exe_file={self.exe_file!r})"
-        )
+        repr = 'CmdStanModel: name={}'.format(self._name)
+        repr = '{}\n\t stan_file={}'.format(repr, self._stan_file)
+        repr = '{}\n\t exe_file={}'.format(repr, self._exe_file)
+        repr = '{}\n\t compiler_options={}'.format(repr, self._compiler_options)
+        return repr
 
     @property
     def name(self) -> str:
         """
-        Model name used in output filename templates.
+        Model name used in output filename templates. Default is basename
+        of Stan program or exe file, unless specified in call to constructor
+        via argument ``model_name``.
         """
         return self._name
 
@@ -212,7 +277,7 @@ class CmdStanModel:
         return self._stan_file
 
     @property
-    def exe_file(self) -> str:
+    def exe_file(self) -> OptionalPath:
         """Full path to Stan exe file."""
         return self._exe_file
 
@@ -220,17 +285,25 @@ class CmdStanModel:
         """
         Run model with option 'info'. Parse output statements, which all
         have form 'key = value' into a Dict.
+        If exe file compiled with CmdStan < 2.27, option 'info' isn't
+        available and the method returns an empty dictionary.
         """
         result: dict[str, str] = {}
-        info = StringIO()
-        do_command(cmd=[self.exe_file, 'info'], fd_out=info)
-        lines = info.getvalue().split('\n')
-        for line in lines:
-            kv_pair = [x.strip() for x in line.split('=')]
-            if len(kv_pair) != 2:
-                continue
-            result[kv_pair[0]] = kv_pair[1]
-        return result
+        if self.exe_file is None:
+            return result
+        try:
+            info = StringIO()
+            do_command(cmd=[str(self.exe_file), 'info'], fd_out=info)
+            lines = info.getvalue().split('\n')
+            for line in lines:
+                kv_pair = [x.strip() for x in line.split('=')]
+                if len(kv_pair) != 2:
+                    continue
+                result[kv_pair[0]] = kv_pair[1]
+            return result
+        except RuntimeError as e:
+            get_logger().debug(e)
+            return result
 
     def src_info(self) -> dict[str, Any]:
         """
@@ -241,7 +314,7 @@ class CmdStanModel:
         """
         if self.stan_file is None or cmdstan_version_before(2, 27):
             return {}
-        return compilation.src_info(str(self.stan_file), self._stanc_options)
+        return compilation.src_info(str(self.stan_file), self._compiler_options)
 
     # TODO(2.0) remove
     def format(
@@ -287,9 +360,24 @@ class CmdStanModel:
             max_line_length=max_line_length,
             canonicalize=canonicalize,
             backup=backup,
-            stanc_options=self._stanc_options,
+            stanc_options=self.stanc_options,
         )
 
+    @property
+    def stanc_options(self) -> dict[str, Union[bool, int, str]]:
+        """Options to stanc compilers."""
+        return self._compiler_options._stanc_options
+
+    @property
+    def cpp_options(self) -> dict[str, Union[bool, int]]:
+        """Options to C++ compilers."""
+        return self._compiler_options._cpp_options
+
+    @property
+    def user_header(self) -> str:
+        """The user header file if it exists, otherwise empty"""
+        return self._compiler_options._user_header
+
     def code(self) -> Optional[str]:
         """Return Stan program as a string."""
         if not self._stan_file:
@@ -305,6 +393,82 @@ class CmdStanModel:
             )
         return code
 
+    # TODO(2.0): remove
+    def compile(
+        self,
+        force: bool = False,
+        stanc_options: Optional[dict[str, Any]] = None,
+        cpp_options: Optional[dict[str, Any]] = None,
+        user_header: OptionalPath = None,
+        override_options: bool = False,
+        *,
+        _internal: bool = False,
+    ) -> None:
+        """
+        Deprecated: To compile a model, use the :class:`~cmdstanpy.CmdStanModel`
+        constructor or :func:`cmdstanpy.compile_stan_file()`.
+
+        Compile the given Stan program file.  Translates the Stan code to
+        C++, then calls the C++ compiler.
+
+        By default, this function compares the timestamps on the source and
+        executable files; if the executable is newer than the source file, it
+        will not recompile the file, unless argument ``force`` is ``True``
+        or unless the compiler options have been changed.
+
+        :param force: When ``True``, always compile, even if the executable file
+            is newer than the source file.  Used for Stan models which have
+            ``#include`` directives in order to force recompilation when changes
+            are made to the included files.
+
+        :param stanc_options: Options for stanc compiler.
+        :param cpp_options: Options for C++ compiler.
+        :param user_header: A path to a header file to include during C++
+            compilation.
+
+        :param override_options: When ``True``, override existing option.
+            When ``False``, add/replace existing options.  Default is ``False``.
+        """
+        if not _internal:
+            get_logger().warning(
+                "CmdStanModel.compile() is deprecated and will be removed in "
+                "the next major version. To compile a model, use the "
+                "CmdStanModel() constructor or cmdstanpy.compile_stan_file()."
+            )
+
+        if not self._stan_file:
+            raise RuntimeError('Please specify source file')
+
+        compiler_options = None
+        if (
+            stanc_options is not None
+            or cpp_options is not None
+            or user_header is not None
+        ):
+            compiler_options = compilation.CompilerOptions(
+                stanc_options=stanc_options,
+                cpp_options=cpp_options,
+                user_header=user_header,
+            )
+            compiler_options.validate()
+
+            if compiler_options != self._compiler_options:
+                force = True
+                if self._compiler_options is None:
+                    self._compiler_options = compiler_options
+                elif override_options:
+                    self._compiler_options = compiler_options
+                else:
+                    self._compiler_options.add(compiler_options)
+
+        self._exe_file = compilation.compile_stan_file(
+            str(self.stan_file),
+            force=force,
+            stanc_options=self._compiler_options.stanc_options,
+            cpp_options=self._compiler_options.cpp_options,
+            user_header=self._compiler_options.user_header,
+        )
+
     @deprecate_positional_args(last_deprecated="jacobian")
     def optimize(
         self,

{cmdstanpy-1.3.1 → cmdstanpy-1.3.2/cmdstanpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmdstanpy
-Version: 1.3.1
+Version: 1.3.2
 Summary: Python interface to CmdStan
 Author: Stan Dev Team
 License: BSD-3-Clause