Merge branch 'develop' into feature/log-prob

Author: WardBrian

cmdstanpy/model.py

@@ -176,9 +176,14 @@ def __init__(
             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
+                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))
@@ -276,32 +281,22 @@ def src_info(self) -> Dict[str, Any]:
         If stanc is older than 2.27 or if the stan
         file cannot be found, returns an empty dictionary.
         """
-        result: Dict[str, Any] = {}
-        if self.stan_file is None:
-            return result
-        try:
-            cmd = (
-                [os.path.join(cmdstan_path(), 'bin', 'stanc' + EXTENSION)]
-                # handle include-paths, allow-undefined etc
-                + self._compiler_options.compose_stanc()
-                + [
-                    '--info',
-                    str(self.stan_file),
-                ]
-            )
-            proc = subprocess.run(
-                cmd, capture_output=True, text=True, check=True
+        if self.stan_file is None or cmdstan_version_before(2, 27):
+            return {}
+        cmd = (
+            [os.path.join(cmdstan_path(), 'bin', 'stanc' + EXTENSION)]
+            # handle include-paths, allow-undefined etc
+            + self._compiler_options.compose_stanc()
+            + ['--info', str(self.stan_file)]
+        )
+        proc = subprocess.run(cmd, capture_output=True, text=True, check=False)
+        if proc.returncode:
+            raise ValueError(
+                f"Failed to get source info for Stan model "
+                f"'{self._stan_file}'. Console:\n{proc.stderr}"
             )
-            result = json.loads(proc.stdout)
-            return result
-        except (
-            ValueError,
-            RuntimeError,
-            OSError,
-            subprocess.CalledProcessError,
-        ) as e:
-            get_logger().debug(e)
-            return result
+        result: Dict[str, Any] = json.loads(proc.stdout)
+        return result
 
     def format(
         self,

requirements-test.txt

@@ -4,6 +4,5 @@ pytest
 pytest-cov
 pytest-order
 mypy
-testfixtures
 tqdm
 xarray

test/__init__.py

@@ -1,81 +1,69 @@
 """Testing utilities for CmdStanPy."""
 
 import contextlib
-import os
-import sys
-import unittest
+import logging
+import platform
+import re
+from typing import List, Type
+from unittest import mock
 from importlib import reload
-from io import StringIO
+import pytest
 
 
-class CustomTestCase(unittest.TestCase):
-    # pylint: disable=invalid-name
-    @contextlib.contextmanager
-    def assertRaisesRegexNested(self, exc, msg):
-        """A version of assertRaisesRegex that checks the full traceback.
+mark_windows_only = pytest.mark.skipif(
+    platform.system() != 'Windows', reason='only runs on windows'
+)
+mark_not_windows = pytest.mark.skipif(
+    platform.system() == 'Windows', reason='does not run on windows'
+)
 
-        Useful for when an exception is raised from another and you wish to
-        inspect the inner exception.
-        """
-        with self.assertRaises(exc) as ctx:
-            yield
-        exception = ctx.exception
-        exn_string = str(ctx.exception)
-        while exception.__cause__ is not None:
-            exception = exception.__cause__
-            exn_string += "\n" + str(exception)
-        self.assertRegex(exn_string, msg)
 
-    @contextlib.contextmanager
-    def without_import(self, library, module):
-        with unittest.mock.patch.dict('sys.modules', {library: None}):
-            reload(module)
-            yield
-        reload(module)
+# pylint: disable=invalid-name
+@contextlib.contextmanager
+def raises_nested(expected_exception: Type[Exception], match: str) -> None:
+    """A version of assertRaisesRegex that checks the full traceback.
 
-    # recipe modified from https://stackoverflow.com/a/36491341
-    @contextlib.contextmanager
-    def replace_stdin(self, target: str):
-        orig = sys.stdin
-        sys.stdin = StringIO(target)
+    Useful for when an exception is raised from another and you wish to
+    inspect the inner exception.
+    """
+    with pytest.raises(expected_exception) as ctx:
         yield
-        sys.stdin = orig
-
-    # recipe from https://stackoverflow.com/a/34333710
-    @contextlib.contextmanager
-    def modified_environ(self, *remove, **update):
-        """
-        Temporarily updates the ``os.environ`` dictionary in-place.
-
-        The ``os.environ`` dictionary is updated in-place so that
-        the modification is sure to work in all situations.
+    exception: Exception = ctx.value
+    lines = []
+    while exception:
+        lines.append(str(exception))
+        exception = exception.__cause__
+    text = "\n".join(lines)
+    assert re.search(match, text), f"pattern `{match}` does not match `{text}`"
 
-        :param remove: Environment variables to remove.
-        :param update: Dictionary of environment variables and values to
-             add/update.
-        """
-        env = os.environ
-        update = update or {}
-        remove = remove or []
 
-        # List of environment variables being updated or removed.
-        stomped = (set(update.keys()) | set(remove)) & set(env.keys())
-        # Environment variables and values to restore on exit.
-        update_after = {k: env[k] for k in stomped}
-        # Environment variables and values to remove on exit.
-        remove_after = frozenset(k for k in update if k not in env)
+@contextlib.contextmanager
+def without_import(library, module):
+    with mock.patch.dict('sys.modules', {library: None}):
+        reload(module)
+        yield
+    reload(module)
 
-        try:
-            env.update(update)
-            for k in remove:
-                env.pop(k, None)
-            yield
-        finally:
-            env.update(update_after)
-            for k in remove_after:
-                env.pop(k)
 
-    # pylint: disable=invalid-name
-    def assertPathsEqual(self, path1, path2):
-        """Assert paths are equal after normalization"""
-        self.assertTrue(os.path.samefile(path1, path2))
+def check_present(
+    caplog: pytest.LogCaptureFixture,
+    *conditions: List[tuple],
+    clear: bool = True,
+) -> None:
+    """
+    Check that all desired records exist.
+    """
+    for condition in conditions:
+        logger, level, message = condition
+        if isinstance(level, str):
+            level = getattr(logging, level)
+        found = any(
+            logger == logger_ and level == level_ and message.match(message_)
+            if isinstance(message, re.Pattern)
+            else message == message_
+            for logger_, level_, message_ in caplog.record_tuples
+        )
+        if not found:
+            raise ValueError(f"logs did not contain the record {condition}")
+    if clear:
+        caplog.clear()

test/conftest.py

@@ -8,9 +8,6 @@
 DATAFILES_PATH = os.path.join(HERE, 'data')
 
 
-# after we have run all tests, use git to delete the built files in data/
-
-
 @pytest.fixture(scope='session', autouse=True)
 def cleanup_test_files():
     """Remove compiled models and output files after test run."""

test/data/.gitignore

@@ -9,3 +9,6 @@
 *.testbak
 *.bak-*
 !return_one.hpp
+# Ignore temporary files created as part of compilation.
+*.o
+*.o.tmp