Merge branch 'develop' into model-formatting

Author: WardBrian

.github/workflows/main.yml

@@ -13,7 +13,7 @@ on:
       cmdstan-version:
         description: 'Version to test'
         required: false
-        default: 'latest'
+        default: ''
 
 jobs:
   get-cmdstan-version:
@@ -24,7 +24,7 @@ jobs:
       - name: Get CmdStan version
         id: check-cmdstan
         run: |
-            if [[ "${{ github.event.inputs.cmdstan-version }}" == "latest" ]]; then
+            if [[ "${{ github.event.inputs.cmdstan-version }}" != "" ]]; then
               echo "::set-output name=version::${{ github.event.inputs.cmdstan-version }}"
             else
                 echo "::set-output name=version::$(python -c 'import requests;print(requests.get("https://api.github.com/repos/stan-dev/cmdstan/releases/latest").json()["tag_name"][1:])')"
@@ -96,14 +96,14 @@ jobs:
         run: |
           install_cmdstan -h
           install_cxx_toolchain -h
-          python -m cmdstanpy.install_cmdstan
+          python -m cmdstanpy.install_cmdstan --version ${{ needs.get-cmdstan-version.outputs.version }}
 
       - name: Install CmdStan (Windows)
         if: matrix.os == 'windows-latest'
         run: |
           install_cmdstan -h
           install_cxx_toolchain -h
-          python -m cmdstanpy.install_cmdstan --compiler
+          python -m cmdstanpy.install_cmdstan --compiler --version ${{ needs.get-cmdstan-version.outputs.version }}
 
       - name: Run tests
         run: |

cmdstanpy/_version.py

@@ -1,3 +1,3 @@
 """PyPi Version"""
 
-__version__ = '1.0.0'
+__version__ = '1.0.1'

cmdstanpy/compiler_opts.py

@@ -3,21 +3,30 @@
 """
 
 import os
+from copy import copy
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
 from cmdstanpy.utils import get_logger
 
 STANC_OPTS = [
     'O',
-    'allow_undefined',
+    'O0',
+    'O1',
+    'Oexperimental',
+    'allow-undefined',
     'use-opencl',
     'warn-uninitialized',
-    'include_paths',
+    'include-paths',
     'name',
     'warn-pedantic',
 ]
 
+STANC_DEPRECATED_OPTS = {
+    'allow_undefined': 'allow-undefined',
+    'include_paths': 'include-paths',
+}
+
 STANC_IGNORE_OPTS = [
     'debug-lex',
     'debug-parse',
@@ -121,41 +130,69 @@ def validate_stanc_opts(self) -> 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)
                 ignore.append(key)
             elif key not in STANC_OPTS:
                 raise ValueError(f'unknown stanc compiler option: {key}')
-            elif key == 'include_paths':
+            elif key == 'include-paths':
                 paths = val
                 if isinstance(val, str):
                     paths = val.split(',')
                 elif not isinstance(val, list):
                     raise ValueError(
-                        'Invalid include_paths, expecting list or '
+                        'Invalid include-paths, expecting list or '
                         f'string, found type: {type(val)}.'
                     )
             elif key == 'use-opencl':
                 if self._cpp_options is None:
                     self._cpp_options = {'STAN_OPENCL': 'TRUE'}
                 else:
                     self._cpp_options['STAN_OPENCL'] = 'TRUE'
+            elif key.startswith('O'):
+                if has_o_flag:
+                    get_logger().warning(
+                        'More than one of (O, O1, O2, Oexperimental)'
+                        'optimizations passed. Only the last one will'
+                        'be used'
+                    )
+                else:
+                    has_o_flag = True
 
         for opt in ignore:
             del self._stanc_options[opt]
         if paths is not None:
-            self._stanc_options['include_paths'] = paths
-            bad_paths = [
-                dir
-                for dir in self._stanc_options['include_paths']
-                if not os.path.exists(dir)
-            ]
+            bad_paths = [dir for dir in paths if not os.path.exists(dir)]
             if any(bad_paths):
                 raise ValueError(
                     'invalid include paths: {}'.format(', '.join(bad_paths))
                 )
 
+            self._stanc_options['include-paths'] = [
+                os.path.abspath(os.path.expanduser(path)) for path in paths
+            ]
+
     def validate_cpp_opts(self) -> None:
         """
         Check cpp compiler args.
@@ -190,8 +227,8 @@ def validate_user_header(self) -> None:
                 raise ValueError(
                     f"Header file must end in .hpp, got {self._user_header}"
                 )
-            if "allow_undefined" not in self._stanc_options:
-                self._stanc_options["allow_undefined"] = True
+            if "allow-undefined" not in self._stanc_options:
+                self._stanc_options["allow-undefined"] = True
             # set full path
             self._user_header = os.path.abspath(self._user_header)
 
@@ -218,7 +255,7 @@ def add(self, new_opts: "CompilerOptions") -> None:  # noqa: disable=Q000
                 self._stanc_options = new_opts.stanc_options
             else:
                 for key, val in new_opts.stanc_options.items():
-                    if key == 'include_paths':
+                    if key == 'include-paths':
                         self.add_include_path(str(val))
                     else:
                         self._stanc_options[key] = val
@@ -230,30 +267,35 @@ def add(self, new_opts: "CompilerOptions") -> None:  # noqa: disable=Q000
 
     def add_include_path(self, path: str) -> None:
         """Adds include path to existing set of compiler options."""
-        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)
+        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(self) -> List[str]:
-        """Format makefile options as list of strings."""
+    def compose_stanc(self) -> List[str]:
         opts = []
         if self._stanc_options is not None and len(self._stanc_options) > 0:
             for key, val in self._stanc_options.items():
-                if key == 'include_paths':
+                if key == 'include-paths':
                     opts.append(
-                        'STANCFLAGS+=--include_paths='
+                        '--include-paths='
                         + ','.join(
                             (
                                 Path(p).as_posix()
-                                for p in self._stanc_options['include_paths']
+                                for p in self._stanc_options['include-paths']
                             )
                         )
                     )
                 elif key == 'name':
-                    opts.append(f'STANCFLAGS+=--name={val}')
+                    opts.append(f'--name={val}')
                 else:
-                    opts.append(f'STANCFLAGS+=--{key}')
+                    opts.append(f'--{key}')
+        return opts
+
+    def compose(self) -> List[str]:
+        """Format makefile options as list of strings."""
+        opts = ['STANCFLAGS+=' + flag for flag in self.compose_stanc()]
         if self._cpp_options is not None and len(self._cpp_options) > 0:
             for key, val in self._cpp_options.items():
                 opts.append(f'{key}={val}')

cmdstanpy/install_cmdstan.py

@@ -460,7 +460,9 @@ def main(args: Dict[str, Any]) -> None:
         print('Installing CmdStan version: {}'.format(version))
     else:
         raise ValueError(
-            'Invalid version requested: {}, cannot install.'.format(version)
+            f'Version {version} cannot be downloaded. '
+            'Connection to GitHub failed. '
+            'Check firewall settings or ensure this version exists.'
         )
 
     cmdstan_dir = os.path.expanduser(os.path.join('~', _DOT_CMDSTAN))

cmdstanpy/model.py

@@ -128,6 +128,8 @@ def __init__(
                 )
             self._name = model_name.strip()
 
+        self._compiler_options.validate()
+
         if stan_file is None:
             if exe_file is None:
                 raise ValueError(
@@ -146,30 +148,25 @@ def __init__(
             if not self._name:
                 self._name, _ = os.path.splitext(filename)
 
-            # TODO: When minimum version is 2.27, use --info instead
             # 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)
-                if self._compiler_options is None:
-                    self._compiler_options = CompilerOptions(
-                        stanc_options={'include_paths': [path]}
-                    )
-                elif self._compiler_options._stanc_options is None:
+                if self._compiler_options._stanc_options is None:
                     self._compiler_options._stanc_options = {
-                        'include_paths': [path]
+                        'include-paths': [path]
                     }
                 else:
                     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, 29
-            ):
+            if not cmdstan_version_before(
+                2, 27
+            ):  # unknown end of version range
                 model_info = self.src_info()
                 if 'parameters' in model_info:
-                    self._fixed_param = len(model_info['parameters']) == 0
+                    self._fixed_param |= len(model_info['parameters']) == 0
 
         if exe_file is not None:
             self._exe_file = os.path.realpath(os.path.expanduser(exe_file))
@@ -186,8 +183,6 @@ def __init__(
                         ' found: {}.'.format(self._name, exename)
                     )
 
-        self._compiler_options.validate()
-
         if platform.system() == 'Windows':
             try:
                 do_command(['where.exe', 'tbb.dll'], fd_out=None)
@@ -279,17 +274,26 @@ def src_info(self) -> Dict[str, Any]:
         if self.stan_file is None:
             return result
         try:
-
-            cmd = [
-                os.path.join('.', 'bin', 'stanc' + EXTENSION),
-                '--info',
-                self.stan_file,
-            ]
-            sout = io.StringIO()
-            do_command(cmd=cmd, cwd=cmdstan_path(), fd_out=sout)
-            result = json.loads(sout.getvalue())
+            cmd = (
+                [os.path.join(cmdstan_path(), 'bin', 'stanc' + EXTENSION)]
+                # handle include-paths, allow-undefined etc
+                + self._compiler_options.compose_stanc()
+                + [
+                    '--info',
+                    self.stan_file,
+                ]
+            )
+            proc = subprocess.run(
+                cmd, capture_output=True, text=True, check=True
+            )
+            result = json.loads(proc.stdout)
             return result
-        except (ValueError, RuntimeError) as e:
+        except (
+            ValueError,
+            RuntimeError,
+            OSError,
+            subprocess.CalledProcessError,
+        ) as e:
             get_logger().debug(e)
             return result