28813810043

Committed 06 Jul 2026 06:24PM UTC coverage: 87.28% (+0.1%) from 87.169%

Build # 28813810043

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #22 from SMTorg/feat/ruff

ci: enforce Ruff linting and formatting

Coverage Stats

486 of 565 new or added lines in 53 files covered. (86.02%)

32 existing lines in 18 files now uncovered.

3719 of 4261 relevant lines covered (87.28%)

1.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.12

/src/tests/test_unit/test_sample.py

import unittest
import numpy as np

from smt_optim.core import Sample, OptimizationDataset

from smt_optim.core.sample import sample_func


class TestSample(unittest.TestCase):
    def test_sample_initialization(self):
        x = np.array([1.0, 2.0])
        obj = np.array([0.5, 1.5])
        cstr = np.array([0.0])
        eval_time = np.array([0.01, 0.02, 0.03])

        s = Sample(
            x=x,
            fidelity=0,
            obj=obj,
            cstr=cstr,
            eval_time=eval_time,
        )

        self.assertTrue(np.array_equal(s.x, x))
        self.assertEqual(s.fidelity, 0)
        self.assertTrue(np.array_equal(s.obj, obj))
        self.assertTrue(np.array_equal(s.cstr, cstr))
        self.assertTrue(np.array_equal(s.eval_time, eval_time))
        self.assertIsInstance(s.metadata, dict)


class TestOptimizationDataset(unittest.TestCase):
    def setUp(self):
        self.dataset = OptimizationDataset()

        # Two objectives, one constraint
        self.s1 = Sample(
            x=np.array([0.0, 1.0]),
            fidelity=0,
            obj=np.array([1.0, 2.0]),
            cstr=np.array([10.0]),
            eval_time=None,
        )

        self.s2 = Sample(
            x=np.array([2.0, 3.0]),
            fidelity=0,
            obj=np.array([3.0, 4.0]),
            cstr=np.array([20.0]),
            eval_time=None,
        )

        self.s3 = Sample(
            x=np.array([4.0, 5.0]),
            fidelity=1,
            obj=np.array([5.0, 6.0]),
            cstr=np.array([30.0]),
            eval_time=None,
        )

        self.s4 = Sample(
            x=np.array([4.1, 5.1]),
            fidelity=1,
            obj=np.array([5.0, 6.0]),
            cstr=np.array([30.0]),
            eval_time=None,
            metadata={
                "scalar": np.pi,
                "array": np.full((2,), np.pi),
                "alpha": "word",
            },
        )

    def test_add_initializes_dimensions(self):
        self.dataset.add(self.s1)

        self.assertEqual(self.dataset.num_obj, 2)
        self.assertEqual(self.dataset.num_cstr, 1)
        self.assertEqual(self.dataset.num_fidelity, 1)
        self.assertIn(0, self.dataset.fidelities)

    def test_add_dimension_mismatch_raises(self):
        self.dataset.add(self.s1)

        bad_sample = Sample(
            x=np.array([1.0, 2.0]),
            fidelity=0,
            obj=np.array([1.0]),  # wrong size
            cstr=np.array([10.0]),
            eval_time=None,
        )

        with self.assertRaises(Exception):
            self.dataset.add(bad_sample)

    def test_add_multiple_fidelities(self):
        self.dataset.add(self.s1)
        self.dataset.add(self.s3)

        self.assertEqual(self.dataset.num_fidelity, 2)
        self.assertCountEqual(self.dataset.fidelities, [0, 1])

    def test_get_by_fidelity(self):
        self.dataset.add(self.s1)
        self.dataset.add(self.s2)
        self.dataset.add(self.s3)

        lvl0 = self.dataset.get_by_fidelity(0)
        lvl1 = self.dataset.get_by_fidelity(1)

        self.assertEqual(len(lvl0), 2)
        self.assertEqual(len(lvl1), 1)
        self.assertTrue(all(s.fidelity == 0 for s in lvl0))
        self.assertTrue(all(s.fidelity == 1 for s in lvl1))

    def test_export_single_objective(self):
        self.dataset.add(self.s1)
        self.dataset.add(self.s2)

        result = self.dataset.export_data(idx=0, lvl=0)

        expected = np.array(
            [
                [1.0],
                [3.0],
            ]
        )

        self.assertTrue(np.array_equal(result, expected))

    def test_export_multiple_objectives(self):
        self.dataset.add(self.s1)
        self.dataset.add(self.s2)

        result = self.dataset.export_data(idx=[0, 1], lvl=0)

        expected = np.array(
            [
                [1.0, 2.0],
                [3.0, 4.0],
            ]
        )

        self.assertTrue(np.array_equal(result, expected))

    def test_export_constraint(self):
        self.dataset.add(self.s1)
        self.dataset.add(self.s2)

        # constraint index is num_obj + 0 = 2
        result = self.dataset.export_data(idx=2, lvl=0)

        expected = np.array(
            [
                [10.0],
                [20.0],
            ]
        )

        self.assertTrue(np.array_equal(result, expected))

    def test_export_mixed_obj_and_constraint(self):
        self.dataset.add(self.s1)
        self.dataset.add(self.s2)

        # objective 1 and constraint 0
        result = self.dataset.export_data(idx=[1, 2], lvl=0)

        expected = np.array(
            [
                [2.0, 10.0],
                [4.0, 20.0],
            ]
        )

        self.assertTrue(np.array_equal(result, expected))

    def test_export_empty_fidelity(self):
        self.dataset.add(self.s1)

        result = self.dataset.export_data(idx=0, lvl=999)

        self.assertEqual(result.shape, (0,))
        self.assertEqual(result.size, 0)

    def test_export_as_dict(self):

        self.dataset.add(self.s1)
        self.dataset.add(self.s2)
        self.dataset.add(self.s3)
        self.dataset.add(self.s4)

        data_as_dict = self.dataset.export_as_dict()

        keys = set(data_as_dict.keys())

        self.assertIn("scalar", keys)
        # test that there is a single scalar value in data_as_dict["scalar"],
        # all other values in the array should be np.nan
        self.assertEqual(data_as_dict["scalar"].shape, (4,))
        finite_idx = np.where(~np.isnan(data_as_dict["scalar"]))[0]
        self.assertEqual(len(finite_idx), 1)
        self.assertEqual(finite_idx[0], 3)
        self.assertEqual(data_as_dict["scalar"][3], self.s4.metadata["scalar"])

        self.assertIn("array", keys)
        # test that the dimension of data_as_dict["array"], should be (4, 2)
        self.assertEqual(data_as_dict["array"].shape, (4, 2))
        self.assertTrue(np.all(np.isnan(data_as_dict["array"][:3, :])))
        # test that only the last row is numerical, all the other value should be np.nan
        np.testing.assert_array_equal(
            data_as_dict["array"][3, :], self.s4.metadata["array"]
        )

        self.assertNotIn("alpha", keys)


class TestEvaluator(unittest.TestCase):
    def test_float_output(self):

        def float_output(x):
            return 0.0

        value, time = sample_func(np.array([0.0]), float_output)

        self.assertEqual(value, 0.0)

    def test_array_output(self):

        def array_1d_output(x):
            return np.array([0.0])

        value, time = sample_func(np.array([0.0]), array_1d_output)
        self.assertEqual(value, 0.0)

        def array_2d_output(x):
            return np.array([[0.0]])

        value, time = sample_func(np.array([0.0]), array_2d_output)
        self.assertEqual(value, 0.0)


if __name__ == "__main__":
    unittest.main()

1	import unittest	2✔
2	import numpy as np	2✔
3
4	from smt_optim.core import Sample, OptimizationDataset	2✔
5
6	from smt_optim.core.sample import sample_func	2✔
7
8
9	class TestSample(unittest.TestCase):	2✔
10	def test_sample_initialization(self):	2✔
11	x = np.array([1.0, 2.0])	2✔
12	obj = np.array([0.5, 1.5])	2✔
13	cstr = np.array([0.0])	2✔
14	eval_time = np.array([0.01, 0.02, 0.03])	2✔
15
16	s = Sample(	2✔
17	x=x,
18	fidelity=0,
19	obj=obj,
20	cstr=cstr,
21	eval_time=eval_time,
22	)
23
24	self.assertTrue(np.array_equal(s.x, x))	2✔
25	self.assertEqual(s.fidelity, 0)	2✔
26	self.assertTrue(np.array_equal(s.obj, obj))	2✔
27	self.assertTrue(np.array_equal(s.cstr, cstr))	2✔
28	self.assertTrue(np.array_equal(s.eval_time, eval_time))	2✔
29	self.assertIsInstance(s.metadata, dict)	2✔
30
31
32	class TestOptimizationDataset(unittest.TestCase):	2✔
33	def setUp(self):	2✔
34	self.dataset = OptimizationDataset()	2✔
35
36	# Two objectives, one constraint
37	self.s1 = Sample(	2✔
38	x=np.array([0.0, 1.0]),
39	fidelity=0,
40	obj=np.array([1.0, 2.0]),
41	cstr=np.array([10.0]),
42	eval_time=None,
43	)
44
45	self.s2 = Sample(	2✔
46	x=np.array([2.0, 3.0]),
47	fidelity=0,
48	obj=np.array([3.0, 4.0]),
49	cstr=np.array([20.0]),
50	eval_time=None,
51	)
52
53	self.s3 = Sample(	2✔
54	x=np.array([4.0, 5.0]),
55	fidelity=1,
56	obj=np.array([5.0, 6.0]),
57	cstr=np.array([30.0]),
58	eval_time=None,
59	)
60
61	self.s4 = Sample(	2✔
62	x=np.array([4.1, 5.1]),
63	fidelity=1,
64	obj=np.array([5.0, 6.0]),
65	cstr=np.array([30.0]),
66	eval_time=None,
67	metadata={
68	"scalar": np.pi,
69	"array": np.full((2,), np.pi),
70	"alpha": "word",
71	},
72	)
73
74	def test_add_initializes_dimensions(self):	2✔
75	self.dataset.add(self.s1)	2✔
76
77	self.assertEqual(self.dataset.num_obj, 2)	2✔
78	self.assertEqual(self.dataset.num_cstr, 1)	2✔
79	self.assertEqual(self.dataset.num_fidelity, 1)	2✔
80	self.assertIn(0, self.dataset.fidelities)	2✔
81
82	def test_add_dimension_mismatch_raises(self):	2✔
83	self.dataset.add(self.s1)	2✔
84
85	bad_sample = Sample(	2✔
86	x=np.array([1.0, 2.0]),
87	fidelity=0,
88	obj=np.array([1.0]), # wrong size
89	cstr=np.array([10.0]),
90	eval_time=None,
91	)
92
93	with self.assertRaises(Exception):	2✔
94	self.dataset.add(bad_sample)	2✔
95
96	def test_add_multiple_fidelities(self):	2✔
97	self.dataset.add(self.s1)	2✔
98	self.dataset.add(self.s3)	2✔
99
100	self.assertEqual(self.dataset.num_fidelity, 2)	2✔
101	self.assertCountEqual(self.dataset.fidelities, [0, 1])	2✔
102
103	def test_get_by_fidelity(self):	2✔
104	self.dataset.add(self.s1)	2✔
105	self.dataset.add(self.s2)	2✔
106	self.dataset.add(self.s3)	2✔
107
108	lvl0 = self.dataset.get_by_fidelity(0)	2✔
109	lvl1 = self.dataset.get_by_fidelity(1)	2✔
110
111	self.assertEqual(len(lvl0), 2)	2✔
112	self.assertEqual(len(lvl1), 1)	2✔
113	self.assertTrue(all(s.fidelity == 0 for s in lvl0))	2✔
114	self.assertTrue(all(s.fidelity == 1 for s in lvl1))	2✔
115
116	def test_export_single_objective(self):	2✔
117	self.dataset.add(self.s1)	2✔
118	self.dataset.add(self.s2)	2✔
119
120	result = self.dataset.export_data(idx=0, lvl=0)	2✔
121
122	expected = np.array(	2✔
123	[
124	[1.0],
125	[3.0],
126	]
127	)
128
129	self.assertTrue(np.array_equal(result, expected))	2✔
130
131	def test_export_multiple_objectives(self):	2✔
132	self.dataset.add(self.s1)	2✔
133	self.dataset.add(self.s2)	2✔
134
135	result = self.dataset.export_data(idx=[0, 1], lvl=0)	2✔
136
137	expected = np.array(	2✔
138	[
139	[1.0, 2.0],
140	[3.0, 4.0],
141	]
142	)
143
144	self.assertTrue(np.array_equal(result, expected))	2✔
145
146	def test_export_constraint(self):	2✔
147	self.dataset.add(self.s1)	2✔
148	self.dataset.add(self.s2)	2✔
149
150	# constraint index is num_obj + 0 = 2
151	result = self.dataset.export_data(idx=2, lvl=0)	2✔
152
153	expected = np.array(	2✔
154	[
155	[10.0],
156	[20.0],
157	]
158	)
159
160	self.assertTrue(np.array_equal(result, expected))	2✔
161
162	def test_export_mixed_obj_and_constraint(self):	2✔
163	self.dataset.add(self.s1)	2✔
164	self.dataset.add(self.s2)	2✔
165
166	# objective 1 and constraint 0
167	result = self.dataset.export_data(idx=[1, 2], lvl=0)	2✔
168
169	expected = np.array(	2✔
170	[
171	[2.0, 10.0],
172	[4.0, 20.0],
173	]
174	)
175
176	self.assertTrue(np.array_equal(result, expected))	2✔
177
178	def test_export_empty_fidelity(self):	2✔
179	self.dataset.add(self.s1)	2✔
180
181	result = self.dataset.export_data(idx=0, lvl=999)	2✔
182
183	self.assertEqual(result.shape, (0,))	2✔
184	self.assertEqual(result.size, 0)	2✔
185
186	def test_export_as_dict(self):	2✔
187
188	self.dataset.add(self.s1)	2✔
189	self.dataset.add(self.s2)	2✔
190	self.dataset.add(self.s3)	2✔
191	self.dataset.add(self.s4)	2✔
192
193	data_as_dict = self.dataset.export_as_dict()	2✔
194
195	keys = set(data_as_dict.keys())	2✔
196
197	self.assertIn("scalar", keys)	2✔
198	# test that there is a single scalar value in data_as_dict["scalar"],
199	# all other values in the array should be np.nan
200	self.assertEqual(data_as_dict["scalar"].shape, (4,))	2✔
201	finite_idx = np.where(~np.isnan(data_as_dict["scalar"]))[0]	2✔
202	self.assertEqual(len(finite_idx), 1)	2✔
203	self.assertEqual(finite_idx[0], 3)	2✔
204	self.assertEqual(data_as_dict["scalar"][3], self.s4.metadata["scalar"])	2✔
205
206	self.assertIn("array", keys)	2✔
207	# test that the dimension of data_as_dict["array"], should be (4, 2)
208	self.assertEqual(data_as_dict["array"].shape, (4, 2))	2✔
209	self.assertTrue(np.all(np.isnan(data_as_dict["array"][:3, :])))	2✔
210	# test that only the last row is numerical, all the other value should be np.nan
211	np.testing.assert_array_equal(	2✔
212	data_as_dict["array"][3, :], self.s4.metadata["array"]
213	)
214
215	self.assertNotIn("alpha", keys)	2✔
216
217
218	class TestEvaluator(unittest.TestCase):	2✔
219	def test_float_output(self):	2✔
220
221	def float_output(x):	2✔
222	return 0.0	2✔
223
224	value, time = sample_func(np.array([0.0]), float_output)	2✔
225
226	self.assertEqual(value, 0.0)	2✔
227
228	def test_array_output(self):	2✔
229
230	def array_1d_output(x):	2✔
231	return np.array([0.0])	2✔
232
233	value, time = sample_func(np.array([0.0]), array_1d_output)	2✔
234	self.assertEqual(value, 0.0)	2✔
235
236	def array_2d_output(x):	2✔
237	return np.array([[0.0]])	2✔
238
239	value, time = sample_func(np.array([0.0]), array_2d_output)	2✔
240	self.assertEqual(value, 0.0)	2✔
241
242
243	if __name__ == "__main__":	2✔
UNCOV 244	unittest.main()	×

SMTorg / smt-optim / 28813810043

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous