Disallow unsupported options

qiskit_ibm_runtime/options/utils.py

@@ -12,7 +12,7 @@
 
 """Utility functions for options."""
 
-from dataclasses import fields, field, make_dataclass
+from dataclasses import fields, make_dataclass
 from ..ibm_backend import IBMBackend
 
 
@@ -92,8 +92,8 @@ def __new__(cls, *_, **kwargs):  # type: ignore
             orig_field_names.add(fld.name)
 
         for key, val in kwargs.items():
-            if key not in orig_field_names:
-                all_fields.append((key, type(val), field(default=None)))
+            if key in dir(cls):
+                setattr(cls, key, val)
 
         new_cls = make_dataclass(
             cls.__name__,

releasenotes/notes/remove_kwargs_options-9024d3ec6572a53e.yaml

@@ -0,0 +1,4 @@
+---
+features:
+  - |
+    Arbitrary keys and values are no longer allowed in ``Options``.

test/unit/test_ibm_primitives.py

@@ -16,7 +16,6 @@
 import copy
 import os
 from unittest.mock import MagicMock, patch
-import warnings
 from dataclasses import asdict
 from typing import Dict
 
@@ -85,28 +84,6 @@ def test_dict_options(self):
                     self._update_dict(expected, copy.deepcopy(options))
                     self.assertDictEqual(expected, inst.options.__dict__)
 
-    def test_backend_in_options(self):
-        """Test specifying backend in options."""
-        primitives = [Sampler, Estimator]
-        backend_name = "ibm_gotham"
-        backend = MagicMock(spec=IBMBackend)
-        backend._instance = None
-        backend.name = backend_name
-        backends = [backend_name, backend]
-        for cls in primitives:
-            for backend in backends:
-                with self.subTest(primitive=cls, backend=backend):
-                    options = {"backend": backend}
-                    with warnings.catch_warnings(record=True) as warn:
-                        warnings.simplefilter("always")
-                        cls(session=MagicMock(spec=MockSession), options=options)
-                        self.assertTrue(
-                            all(
-                                issubclass(one_warn.category, DeprecationWarning)
-                                for one_warn in warn
-                            )
-                        )
-
     def test_runtime_options(self):
         """Test RuntimeOptions specified as primitive options."""
         session = MagicMock(spec=MockSession)
@@ -415,22 +392,6 @@ def test_run_overwrite_runtime_options(self):
                         rt_options = kwargs["options"]
                     self._assert_dict_partially_equal(rt_options, options)
 
-    def test_kwarg_options(self):
-        """Test specifying arbitrary options."""
-        session = MagicMock(spec=MockSession)
-        primitives = [Sampler, Estimator]
-        for cls in primitives:
-            with self.subTest(primitive=cls):
-                options = Options(foo="foo")  # pylint: disable=unexpected-keyword-arg
-                inst = cls(session=session, options=options)
-                inst.run(self.qx, observables=self.obs)
-                if sys.version_info >= (3, 8):
-                    inputs = session.run.call_args.kwargs["inputs"]
-                else:
-                    _, kwargs = session.run.call_args
-                    inputs = kwargs["inputs"]
-                self.assertEqual(inputs.get("foo"), "foo")
-
     def test_run_kwarg_options(self):
         """Test specifying arbitrary options in run."""
         session = MagicMock(spec=MockSession)
@@ -477,10 +438,6 @@ def test_set_options(self):
         new_options = [
             ({"optimization_level": 2}, Options()),
             ({"optimization_level": 3, "shots": 200}, Options()),
-            (
-                {"shots": 300, "foo": "foo"},
-                Options(foo="foo"),  # pylint: disable=unexpected-keyword-arg
-            ),
         ]
 
         session = MagicMock(spec=MockSession)

test/unit/test_options.py

@@ -12,7 +12,6 @@
 
 """Tests for Options class."""
 
-import warnings
 from dataclasses import asdict
 
 from ddt import data, ddt
@@ -62,51 +61,6 @@ def test_merge_options(self):
                     f"options={options}, combined={combined}",
                 )
 
-    def test_merge_options_extra_fields(self):
-        """Test merging options with extra fields."""
-        options_vars = [
-            (
-                {
-                    "initial_layout": [2, 3],
-                    "transpilation": {"layout_method": "trivial"},
-                    "foo": "foo",
-                },
-                Options(foo="foo"),  # pylint: disable=unexpected-keyword-arg
-            ),
-            (
-                {
-                    "initial_layout": [3, 4],
-                    "transpilation": {"layout_method": "dense", "bar": "bar"},
-                },
-                Options(transpilation={"bar": "bar"}),
-            ),
-            (
-                {
-                    "initial_layout": [1, 2],
-                    "foo": "foo",
-                    "transpilation": {"layout_method": "dense", "foo": "foo"},
-                },
-                Options(  # pylint: disable=unexpected-keyword-arg
-                    foo="foo", transpilation={"foo": "foo"}
-                ),
-            ),
-        ]
-        for new_ops, expected in options_vars:
-            with self.subTest(new_ops=new_ops):
-                options = Options()
-                combined = Options._merge_options(asdict(options), new_ops)
-
-                # Make sure the values are equal.
-                self.assertTrue(
-                    flat_dict_partially_equal(combined, new_ops),
-                    f"new_ops={new_ops}, combined={combined}",
-                )
-                # Make sure the structure didn't change.
-                self.assertTrue(
-                    dict_keys_equal(combined, asdict(expected)),
-                    f"expected={expected}, combined={combined}",
-                )
-
     def test_runtime_options(self):
         """Test converting runtime options."""
         full_options = RuntimeOptions(
@@ -137,14 +91,8 @@ def test_program_inputs(self):
             environment={"log_level": "DEBUG"},
             simulator={"noise_model": noise_model},
             resilience={"noise_factors": (0, 2, 4)},
-            foo="foo",
-            bar="bar",
         )
-
-        with warnings.catch_warnings(record=True) as warn:
-            warnings.simplefilter("always")
-            inputs = Options._get_program_inputs(asdict(options))
-            self.assertEqual(len(warn), 2)
+        inputs = Options._get_program_inputs(asdict(options))
 
         expected = {
             "run_options": {"shots": 100, "noise_model": noise_model},
@@ -157,7 +105,6 @@ def test_program_inputs(self):
                 "level": 2,
                 "noise_factors": (0, 2, 4),
             },
-            "foo": "foo",
         }
         self.assertTrue(
             dict_paritally_equal(inputs, expected),
@@ -191,6 +138,30 @@ def test_init_options_with_dictionary(self):
                 # Make sure the structure didn't change.
                 self.assertTrue(dict_keys_equal(asdict(Options()), options), f"options={options}")
 
+    def test_kwargs_options(self):
+        """Test specifying arbitrary options."""
+        with self.assertRaises(TypeError) as exc:
+            _ = Options(foo="foo")  # pylint: disable=unexpected-keyword-arg
+        self.assertIn(
+            "__init__() got an unexpected keyword argument 'foo'",
+            str(exc.exception),
+        )
+
+    def test_backend_in_options(self):
+        """Test specifying backend in options."""
+        backend_name = "ibm_gotham"
+        backend = FakeManila()
+        backend._instance = None
+        backend.name = backend_name
+        backends = [backend_name, backend]
+        for backend in backends:
+            with self.assertRaises(TypeError) as exc:
+                _ = Options(backend=backend)  # pylint: disable=unexpected-keyword-arg
+            self.assertIn(
+                "__init__() got an unexpected keyword argument 'backend'",
+                str(exc.exception),
+            )
+
     def test_unsupported_options(self):
         """Test error on unsupported second level options"""
         # defining minimal dict of options