Use cpp-opts internally for user header, check clashes

Author: WardBrian

cmdstanpy/compiler_opts.py

@@ -70,8 +70,8 @@ def __init__(
             )
 
     def __repr__(self) -> str:
-        return 'stanc_options={}, cpp_options={}, user_header={}'.format(
-            self._stanc_options, self._cpp_options, self._user_header
+        return 'stanc_options={}, cpp_options={}'.format(
+            self._stanc_options, self._cpp_options
         )
 
     @property
@@ -84,11 +84,6 @@ def cpp_options(self) -> Dict[str, Union[bool, int]]:
         """C++ compiler options."""
         return self._cpp_options
 
-    @property
-    def user_header(self) -> str:
-        """The user header file if it exists, otherwise empty"""
-        return self._user_header
-
     def validate(self) -> None:
         """
         Check compiler args.
@@ -184,9 +179,20 @@ def validate_user_header(self) -> None:
 
             if ' ' in self._user_header:
                 raise ValueError(
-                    "User header must be in a folder with no spaces in path!"
+                    "User header must be in a location with no spaces in path!"
                 )
 
+            if (
+                'USER_HEADER' in self._cpp_options
+                and self._user_header != self._cpp_options['USER_HEADER']
+            ):
+                raise ValueError(
+                    "Disagreement in user_header C++ options found!\n"
+                    f"{self._user_header}, {self._cpp_options['USER_HEADER']}"
+                )
+
+            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:
@@ -201,8 +207,8 @@ def add(self, new_opts: "CompilerOptions") -> None:  # noqa: disable=Q000
         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
+        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."""
@@ -233,6 +239,4 @@ def compose(self) -> List[str]:
         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}')
-        if self._user_header:
-            opts.append(f'USER_HEADER={self._user_header}')
         return opts

docsrc/env.yml

@@ -6,6 +6,7 @@ dependencies:
   - python=3.7
   - ipykernel
   - ipython
+  - ipywidgets
   - numpy>=1.15
   - pandas
   - xarray

docsrc/examples/Using External C++.ipynb

@@ -2,103 +2,116 @@
  "cells": [
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "# Advanced Topic: Using External C++ Functions\n",
     "\n",
     "This is based on the relevant portion of the CmdStan documentation [here](https://mc-stan.org/docs/cmdstan-guide/using-external-cpp-code.html)"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "Consider the following Stan model, based on the bernoulli example."
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "metadata": {"nbsphinx": "hidden"},
+   "outputs": [],
    "source": [
     "import os\n",
-    "from cmdstanpy import cmdstan_path, CmdStanModel\n",
+    "try:\n",
+    "    os.remove('bernoulli_external')\n",
+    "except:\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cmdstanpy import CmdStanModel\n",
     "model_external = CmdStanModel(stan_file='bernoulli_external.stan', compile=False)\n",
     "print(model_external.code())"
-   ],
-   "outputs": [],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "As you can see, it features a function declaration for `make_odds`, but no definition. If we try to compile this, we will get an error. "
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "model_external.compile()"
-   ],
-   "outputs": [],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "Even enabling the `--allow_undefined` flag to stanc3 will not allow this model to be compiled quite yet."
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "model_external.compile(stanc_options={'allow_undefined':True})"
-   ],
-   "outputs": [],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "To resolve this, we need to both tell the Stan compiler an undefined function is okay **and** let C++ know what it should be. \n",
     "\n",
     "We can provide a definition in a C++ header file by using the `user_header` argument to either the CmdStanModel constructor or the `compile` method. \n",
     "\n",
     "This will enables the `allow_undefined` flag automatically."
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "model_external.compile(user_header='make_odds.hpp')"
-   ],
-   "outputs": [],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "We can then run this model and inspect the output"
-   ],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "fit = model_external.sample(data={'N':10, 'y':[0,1,0,0,0,0,0,0,0,1]})\n",
     "fit.stan_variable('odds')"
-   ],
-   "outputs": [],
-   "metadata": {}
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
     "The contents of this header file are a bit complicated unless you are familiar with the C++ internals of Stan, so they are presented without comment:\n",
     "\n",
@@ -114,32 +127,31 @@
     "       }\n",
     "}\n",
     "```"
-   ],
-   "metadata": {}
+   ]
   }
  ],
  "metadata": {
-  "orig_nbformat": 4,
+  "interpreter": {
+   "hash": "8765ce46b013071999fc1966b52035a7309a0da7551e066cc0f0fa23e83d4f60"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.9.5 64-bit ('stan': conda)",
+   "name": "python3"
+  },
   "language_info": {
-   "name": "python",
-   "version": "3.9.5",
-   "mimetype": "text/x-python",
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
-   "pygments_lexer": "ipython3",
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
    "nbconvert_exporter": "python",
-   "file_extension": ".py"
-  },
-  "kernelspec": {
-   "name": "python3",
-   "display_name": "Python 3.9.5 64-bit ('stan': conda)"
+   "pygments_lexer": "ipython3",
+   "version": "3.9.5"
   },
-  "interpreter": {
-   "hash": "d31ce8e45781476cfd394e192e0962028add96ff436d4fd4e560a347d206b9cb"
-  }
+  "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 2
-}
+}

test/test_compiler_opts.py

@@ -14,9 +14,7 @@ def test_opts_empty(self):
         opts = CompilerOptions()
         opts.validate()
         self.assertEqual(opts.compose(), [])
-        self.assertEqual(
-            opts.__repr__(), 'stanc_options={}, cpp_options={}, user_header='
-        )
+        self.assertEqual(opts.__repr__(), 'stanc_options={}, cpp_options={}')
 
         stanc_opts = {}
         opts = CompilerOptions(stanc_options=stanc_opts)
@@ -31,9 +29,7 @@ def test_opts_empty(self):
         opts = CompilerOptions(stanc_options=stanc_opts, cpp_options=cpp_opts)
         opts.validate()
         self.assertEqual(opts.compose(), [])
-        self.assertEqual(
-            opts.__repr__(), 'stanc_options={}, cpp_options={}, user_header='
-        )
+        self.assertEqual(opts.__repr__(), 'stanc_options={}, cpp_options={}')
 
     def test_opts_stanc(self):
         stanc_opts = {}
@@ -174,6 +170,13 @@ def test_user_header(self):
         with self.assertRaisesRegex(ValueError, "must end in .hpp"):
             opts.validate()
 
+        header_file = os.path.join(DATAFILES_PATH, 'return_one.hpp')
+        opts = CompilerOptions(
+            user_header=header_file, cpp_options={'USER_HEADER': 'foo'}
+        )
+        with self.assertRaisesRegex(ValueError, "Disagreement"):
+            opts.validate()
+
     def test_opts_add(self):
         stanc_opts = {'warn-uninitialized': True}
         cpp_opts = {'STAN_OPENCL': 'TRUE', 'OPENCL_DEVICE_ID': 1}
@@ -213,7 +216,10 @@ def test_opts_add(self):
         opts = CompilerOptions()
         opts.add(CompilerOptions(user_header=header_file))
         opts_list = opts.compose()
-        self.assertTrue(len(opts_list) == 1)
+        self.assertEqual(len(opts_list), 0)
+        opts.validate()
+        opts_list = opts.compose()
+        self.assertEqual(len(opts_list), 2)
 
 
 if __name__ == '__main__':