humalab 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

humalab/{scenario_test.py → scenarios/scenario_test.py}

@@ -1,6 +1,6 @@
 import unittest
 import numpy as np
-from humalab.scenario import Scenario
+from humalab.scenarios.scenario import Scenario
 
 
 class ScenarioTest(unittest.TestCase):
@@ -9,8 +9,6 @@ class ScenarioTest(unittest.TestCase):
     def setUp(self):
         """Set up test fixtures before each test method."""
         self.scenario = Scenario()
-        self.run_id = "test_run_id"
-        self.episode_id = "test_episode_id"
 
     def tearDown(self):
         """Clean up after each test method."""
@@ -23,17 +21,13 @@ class ScenarioTest(unittest.TestCase):
 
         # In-test
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=None,
             seed=42
         )
 
         # Post-condition
-        self.assertEqual(self.scenario._run_id, self.run_id)
-        self.assertEqual(self.scenario._episode_id, self.episode_id)
         self.assertIsNotNone(self.scenario._scenario_id)
-        self.assertEqual(len(self.scenario._cur_scenario), 0)
+        self.assertEqual(len(self.scenario._scenario_template), 0)
 
     def test_init_should_initialize_with_dict_scenario(self):
         """Test that init() correctly processes dict-based scenario."""
@@ -45,15 +39,14 @@ class ScenarioTest(unittest.TestCase):
 
         # In-test
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_dict,
             seed=42
         )
 
         # Post-condition
-        self.assertEqual(self.scenario.test_key, "test_value")
-        self.assertEqual(self.scenario.nested.inner_key, "inner_value")
+        resolved, _ = self.scenario.resolve()
+        self.assertEqual(resolved.test_key, "test_value")
+        self.assertEqual(resolved.nested.inner_key, "inner_value")
 
     def test_init_should_use_provided_scenario_id(self):
         """Test that init() uses provided scenario_id."""
@@ -62,8 +55,6 @@ class ScenarioTest(unittest.TestCase):
 
         # In-test
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario={},
             scenario_id=custom_id
         )
@@ -80,21 +71,19 @@ class ScenarioTest(unittest.TestCase):
         # In-test
         scenario1 = Scenario()
         scenario1.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config,
             seed=seed
         )
-        value1 = scenario1.value
+        resolved1, _ = scenario1.resolve()
+        value1 = resolved1.value
 
         scenario2 = Scenario()
         scenario2.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config,
             seed=seed
         )
-        value2 = scenario2.value
+        resolved2, _ = scenario2.resolve()
+        value2 = resolved2.value
 
         # Post-condition
         self.assertEqual(value1, value2)
@@ -112,38 +101,36 @@ class ScenarioTest(unittest.TestCase):
 
         # In-test
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config,
             seed=42
         )
 
         # Post-condition
-        value = self.scenario.uniform_value
+        resolved, _ = self.scenario.resolve()
+        value = resolved.uniform_value
         self.assertIsInstance(value, (int, float))
         self.assertGreaterEqual(value, 0.0)
         self.assertLessEqual(value, 1.0)
 
     def test_uniform_distribution_should_handle_size_parameter(self):
-        """Test that uniform distribution with size parameter returns list."""
+        """Test that uniform_1d distribution returns list."""
         # Pre-condition
         scenario_config = {
-            "uniform_array": "${uniform: 0.0, 1.0, 5}"
+            "uniform_array": "${uniform_1d: 0.0, 1.0}"
         }
 
         # In-test
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config,
             seed=42
         )
 
         # Post-condition
-        value = self.scenario.uniform_array
+        resolved, _ = self.scenario.resolve()
+        value = resolved.uniform_array
         # Convert to list if it's a ListConfig
-        value_list = list(value) if hasattr(value, '__iter__') else [value]
-        self.assertEqual(len(value_list), 5)
+        value_list = list(value) if hasattr(value, '__iter__') and not isinstance(value, str) else [value]
+        self.assertGreaterEqual(len(value_list), 1)
         for v in value_list:
             self.assertGreaterEqual(v, 0.0)
             self.assertLessEqual(v, 1.0)
@@ -157,36 +144,34 @@ class ScenarioTest(unittest.TestCase):
 
         # In-test
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config,
             seed=42
         )
 
         # Post-condition
-        value = self.scenario.gaussian_value
+        resolved, _ = self.scenario.resolve()
+        value = resolved.gaussian_value
         self.assertIsInstance(value, (int, float))
 
     def test_gaussian_distribution_should_handle_size_parameter(self):
-        """Test that gaussian distribution with size parameter returns list."""
+        """Test that gaussian_1d distribution returns list."""
         # Pre-condition
         scenario_config = {
-            "gaussian_array": "${gaussian: 0.0, 1.0, 3}"
+            "gaussian_array": "${gaussian_1d: 0.0, 1.0}"
         }
 
         # In-test
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config,
             seed=42
         )
 
         # Post-condition
-        value = self.scenario.gaussian_array
+        resolved, _ = self.scenario.resolve()
+        value = resolved.gaussian_array
         # Convert to list if it's a ListConfig
-        value_list = list(value) if hasattr(value, '__iter__') else [value]
-        self.assertEqual(len(value_list), 3)
+        value_list = list(value) if hasattr(value, '__iter__') and not isinstance(value, str) else [value]
+        self.assertGreaterEqual(len(value_list), 1)
 
     def test_bernoulli_distribution_should_resolve_correctly(self):
         """Test that bernoulli distribution resolver works correctly."""
@@ -197,159 +182,145 @@ class ScenarioTest(unittest.TestCase):
 
         # In-test
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config,
             seed=42
         )
 
         # Post-condition
-        value = self.scenario.bernoulli_value
+        resolved, _ = self.scenario.resolve()
+        value = resolved.bernoulli_value
         self.assertIn(value, [0, 1, True, False])
 
-    def test_reset_should_regenerate_distribution_values(self):
-        """Test that reset() regenerates new values from distributions."""
+    def test_resolve_should_regenerate_distribution_values(self):
+        """Test that resolve() regenerates new values from distributions."""
         # Pre-condition
         scenario_config = {
             "random_value": "${uniform: 0.0, 100.0}"
         }
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config,
             seed=None  # No seed for randomness
         )
-        _ = self.scenario.random_value  # Access once to populate cache
 
-        # In-test
-        self.scenario.reset(episode_id="new_episode")
+        # In-test - First resolve
+        resolved1, _ = self.scenario.resolve()
+        value1 = resolved1.random_value
+
+        # Second resolve
+        resolved2, _ = self.scenario.resolve()
+        value2 = resolved2.random_value
 
         # Post-condition
-        second_value = self.scenario.random_value
         # Values should be different (statistically very unlikely to be same)
         # Note: There's a tiny chance they could be equal, but extremely unlikely
-        self.assertIsInstance(second_value, (int, float))
+        self.assertIsInstance(value1, (int, float))
+        self.assertIsInstance(value2, (int, float))
 
-    def test_getattr_should_access_scenario_values(self):
-        """Test that __getattr__ allows attribute-style access."""
+    def test_template_property_should_access_scenario_template(self):
+        """Test that template property allows access to scenario values."""
         # Pre-condition
         scenario_config = {
             "test_attribute": "test_value"
         }
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config
         )
 
         # In-test
-        value = self.scenario.test_attribute
+        value = self.scenario.template.test_attribute
 
         # Post-condition
         self.assertEqual(value, "test_value")
 
-    def test_getattr_should_raise_error_for_missing_attribute(self):
-        """Test that __getattr__ raises AttributeError for missing attributes."""
+    def test_template_should_contain_unresolved_distributions(self):
+        """Test that template contains unresolved distribution strings."""
         # Pre-condition
+        scenario_config = {
+            "test_key": "${uniform: 0.0, 1.0}"
+        }
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
-            scenario={}
+            scenario=scenario_config
         )
 
-        # In-test & Post-condition
-        with self.assertRaises(AttributeError) as context:
-            _ = self.scenario.nonexistent_attribute
-        self.assertIn("nonexistent_attribute", str(context.exception))
+        # In-test
+        yaml_str = self.scenario.yaml
+
+        # Post-condition
+        self.assertIn("uniform", yaml_str)
 
-    def test_getitem_should_access_scenario_values(self):
-        """Test that __getitem__ allows dict-style access."""
+    def test_resolve_should_return_resolved_values(self):
+        """Test that resolve() returns dict-style access to resolved values."""
         # Pre-condition
         scenario_config = {
             "test_key": "test_value"
         }
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config
         )
 
         # In-test
-        value = self.scenario["test_key"]
+        resolved, _ = self.scenario.resolve()
+        value = resolved["test_key"]
 
         # Post-condition
         self.assertEqual(value, "test_value")
 
-    def test_getitem_should_raise_error_for_missing_key(self):
-        """Test that __getitem__ raises KeyError for missing keys."""
+    def test_resolve_should_raise_error_for_missing_key(self):
+        """Test that resolve() result raises KeyError for missing keys."""
         # Pre-condition
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario={}
         )
 
         # In-test & Post-condition
-        with self.assertRaises(KeyError) as context:
-            _ = self.scenario["nonexistent_key"]
-        self.assertIn("nonexistent_key", str(context.exception))
+        resolved, _ = self.scenario.resolve()
+        with self.assertRaises(KeyError):
+            _ = resolved["nonexistent_key"]
 
-    def test_get_final_size_should_handle_none_size_with_num_env(self):
-        """Test _get_final_size with None size and num_env set."""
+    def test_get_final_size_should_handle_none_size_without_num_env(self):
+        """Test _get_final_size with None size and no num_env."""
         # Pre-condition
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
-            scenario={},
-            num_env=4
+            scenario={}
         )
 
         # In-test
         result = self.scenario._get_final_size(None)
 
         # Post-condition
-        self.assertEqual(result, 4)
+        self.assertIsNone(result)
 
-    def test_get_final_size_should_handle_int_size_with_num_env(self):
-        """Test _get_final_size with int size and num_env set."""
+    def test_get_final_size_should_handle_int_size_without_num_env(self):
+        """Test _get_final_size with int size and no num_env."""
         # Pre-condition
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
-            scenario={},
-            num_env=4
+            scenario={}
         )
 
         # In-test
         result = self.scenario._get_final_size(3)
 
         # Post-condition
-        self.assertEqual(result, (4, 3))
+        self.assertEqual(result, 3)
 
-    def test_get_final_size_should_handle_tuple_size_with_num_env(self):
-        """Test _get_final_size with tuple size and num_env set."""
+    def test_get_final_size_should_handle_tuple_size_without_num_env(self):
+        """Test _get_final_size with tuple size and no num_env."""
         # Pre-condition
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
-            scenario={},
-            num_env=4
+            scenario={}
         )
 
         # In-test
         result = self.scenario._get_final_size((2, 3))
 
         # Post-condition
-        self.assertEqual(result, (4, 2, 3))
+        self.assertEqual(result, (2, 3))
 
     def test_get_final_size_should_handle_size_without_num_env(self):
         """Test _get_final_size with size but no num_env."""
         # Pre-condition
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
-            scenario={},
-            num_env=None
+            scenario={}
         )
 
         # In-test
@@ -409,8 +380,6 @@ class ScenarioTest(unittest.TestCase):
         # Pre-condition
         root = {"key1": "target_node", "key2": "other"}
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario={}
         )
 
@@ -425,8 +394,6 @@ class ScenarioTest(unittest.TestCase):
         # Pre-condition
         root = {"level1": {"level2": "target_node"}}
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario={}
         )
 
@@ -441,8 +408,6 @@ class ScenarioTest(unittest.TestCase):
         # Pre-condition
         root = {"key": ["item1", "target_node", "item3"]}
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario={}
         )
 
@@ -457,8 +422,6 @@ class ScenarioTest(unittest.TestCase):
         # Pre-condition
         root = {"key": "value"}
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario={}
         )
 
@@ -473,8 +436,6 @@ class ScenarioTest(unittest.TestCase):
         # Pre-condition
         scenario_config = {"key": "value"}
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config
         )
 
@@ -485,30 +446,26 @@ class ScenarioTest(unittest.TestCase):
         self.assertIsNotNone(template)
         self.assertEqual(template.key, "value")
 
-    def test_cur_scenario_property_should_return_current_scenario(self):
-        """Test that cur_scenario property returns the current scenario."""
+    def test_resolve_should_return_resolved_scenario(self):
+        """Test that resolve() returns the resolved scenario."""
         # Pre-condition
         scenario_config = {"key": "value"}
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config
         )
 
         # In-test
-        cur_scenario = self.scenario.cur_scenario
+        resolved, _ = self.scenario.resolve()
 
         # Post-condition
-        self.assertIsNotNone(cur_scenario)
-        self.assertEqual(cur_scenario.key, "value")
+        self.assertIsNotNone(resolved)
+        self.assertEqual(resolved.key, "value")
 
     def test_yaml_property_should_return_yaml_representation(self):
         """Test that yaml property returns YAML string."""
         # Pre-condition
         scenario_config = {"key": "value"}
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config
         )
 
@@ -520,27 +477,25 @@ class ScenarioTest(unittest.TestCase):
         self.assertIn("key:", yaml_str)
         self.assertIn("value", yaml_str)
 
-    def test_finish_should_call_finish_on_metrics(self):
-        """Test that finish() calls finish on all metrics."""
+    def test_resolve_returns_episode_vals(self):
+        """Test that resolve() returns episode values for distributions."""
         # Pre-condition
         scenario_config = {
             "dist_value": "${uniform: 0.0, 1.0}"
         }
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config,
             seed=42
         )
-        # Access the value to create the metric
-        _ = self.scenario.dist_value
 
         # In-test
-        self.scenario.finish()
+        resolved, episode_vals = self.scenario.resolve()
 
         # Post-condition
-        # Verify metrics exist and finish was called
-        self.assertGreater(len(self.scenario._metrics), 0)
+        # Verify resolved scenario has the value
+        self.assertIsNotNone(resolved.dist_value)
+        # Verify episode_vals dict contains the distribution samples
+        self.assertGreater(len(episode_vals), 0)
 
     def test_nested_scenario_access_should_work(self):
         """Test accessing deeply nested scenario values."""
@@ -553,13 +508,12 @@ class ScenarioTest(unittest.TestCase):
             }
         }
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config
         )
 
         # In-test
-        value = self.scenario.level1.level2.level3
+        resolved, _ = self.scenario.resolve()
+        value = resolved.level1.level2.level3
 
         # Post-condition
         self.assertEqual(value, "deep_value")
@@ -575,50 +529,25 @@ class ScenarioTest(unittest.TestCase):
 
         # In-test
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
-            scenario=scenario_config,
-            seed=42
-        )
-
-        # Post-condition
-        self.assertIsInstance(self.scenario.uniform_val, (int, float))
-        self.assertIsInstance(self.scenario.gaussian_val, (int, float))
-        self.assertIn(self.scenario.bernoulli_val, [0, 1, True, False])
-
-    def test_num_env_should_affect_distribution_size(self):
-        """Test that num_env parameter affects distribution output size."""
-        # Pre-condition
-        scenario_config = {
-            "value": "${uniform: 0.0, 1.0}"
-        }
-
-        # In-test
-        self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config,
-            num_env=3,
             seed=42
         )
 
         # Post-condition
-        value = self.scenario.value
-        # Convert to list if it's a ListConfig
-        value_list = list(value) if hasattr(value, '__iter__') else [value]
-        self.assertEqual(len(value_list), 3)
+        resolved, _ = self.scenario.resolve()
+        self.assertIsInstance(resolved.uniform_val, (int, float))
+        self.assertIsInstance(resolved.gaussian_val, (int, float))
+        self.assertIn(resolved.bernoulli_val, [0, 1, True, False])
 
     def test_clear_resolvers_should_clear_dist_cache(self):
         """Test that _clear_resolvers clears the distribution cache."""
         # Pre-condition
         scenario_config = {"value": "${uniform: 0.0, 1.0}"}
         self.scenario.init(
-            run_id=self.run_id,
-            episode_id=self.episode_id,
             scenario=scenario_config,
             seed=42
         )
-        _ = self.scenario.value  # Trigger cache population
+        _ = self.scenario.resolve()  # Trigger cache population
 
         # In-test
         self.scenario._clear_resolvers()
@@ -639,36 +568,25 @@ class ScenarioTest(unittest.TestCase):
 
         # In-test
         self.scenario.init(
-            run_id="run_id",
-            episode_id="episode_id",
             scenario=scenario_config,
-            seed=42,
-            num_env=2
+            seed=42
         )
 
         # Post-condition
         # Verify scenario structure exists
-        self.assertIsNotNone(self.scenario.scenario)
-        self.assertEqual(self.scenario.scenario.scenario_id, "scenario_1")
-
-        # Verify cup_x and cup_y are resolved and are lists (due to num_env=2)
-        cup_x = self.scenario.scenario.cup_x
-        cup_y = self.scenario.scenario.cup_y
+        resolved, _ = self.scenario.resolve()
+        self.assertIsNotNone(resolved.scenario)
+        self.assertEqual(resolved.scenario.scenario_id, "scenario_1")
 
-        cup_x_list = list(cup_x) if hasattr(cup_x, '__iter__') else [cup_x]
-        cup_y_list = list(cup_y) if hasattr(cup_y, '__iter__') else [cup_y]
-
-        self.assertEqual(len(cup_x_list), 2)
-        self.assertEqual(len(cup_y_list), 2)
+        # Verify cup_x and cup_y are resolved
+        cup_x = resolved.scenario.cup_x
+        cup_y = resolved.scenario.cup_y
 
         # Verify values are in expected ranges
-        for val in cup_x_list:
-            self.assertGreaterEqual(val, 0.7)
-            self.assertLessEqual(val, 1.5)
-
-        for val in cup_y_list:
-            self.assertGreaterEqual(val, 0.3)
-            self.assertLessEqual(val, 0.7)
+        self.assertGreaterEqual(cup_x, 0.7)
+        self.assertLessEqual(cup_x, 1.5)
+        self.assertGreaterEqual(cup_y, 0.3)
+        self.assertLessEqual(cup_y, 0.7)
 
     def test_main_script_scenario_should_allow_both_access_methods(self):
         """Test that both attribute and dict access work as shown in __main__ script."""
@@ -682,26 +600,20 @@ class ScenarioTest(unittest.TestCase):
 
         # In-test
         self.scenario.init(
-            run_id="run_id",
-            episode_id="episode_id",
             scenario=scenario_config,
-            seed=42,
-            num_env=2
+            seed=42
         )
 
         # Post-condition
         # Both access methods should return the same value
-        cup_x_attr = self.scenario.scenario.cup_x
-        cup_x_dict = self.scenario["scenario"].cup_x
-
-        # Convert to lists for comparison
-        cup_x_attr_list = list(cup_x_attr) if hasattr(cup_x_attr, '__iter__') else [cup_x_attr]
-        cup_x_dict_list = list(cup_x_dict) if hasattr(cup_x_dict, '__iter__') else [cup_x_dict]
+        resolved, _ = self.scenario.resolve()
+        cup_x_attr = resolved.scenario.cup_x
+        cup_x_dict = resolved["scenario"].cup_x
 
-        self.assertEqual(cup_x_attr_list, cup_x_dict_list)
+        self.assertEqual(cup_x_attr, cup_x_dict)
 
-    def test_main_script_scenario_should_regenerate_on_reset(self):
-        """Test that reset regenerates values as shown in __main__ script."""
+    def test_main_script_scenario_should_regenerate_on_resolve(self):
+        """Test that resolve regenerates values as shown in __main__ script."""
         # Pre-condition
         scenario_config = {
             "scenario": {
@@ -709,58 +621,47 @@ class ScenarioTest(unittest.TestCase):
             }
         }
         self.scenario.init(
-            run_id="run_id",
-            episode_id="episode_id",
             scenario=scenario_config,
-            seed=None,  # No seed for random values
-            num_env=2
+            seed=None  # No seed for random values
         )
 
-        first_cup_x = self.scenario.scenario.cup_x
-        first_list = list(first_cup_x) if hasattr(first_cup_x, '__iter__') else [first_cup_x]
+        resolved1, _ = self.scenario.resolve()
+        first_cup_x = resolved1.scenario.cup_x
 
         # In-test
-        self.scenario.reset()
+        resolved2, _ = self.scenario.resolve()
+        second_cup_x = resolved2.scenario.cup_x
 
         # Post-condition
-        second_cup_x = self.scenario.scenario.cup_x
-        second_list = list(second_cup_x) if hasattr(second_cup_x, '__iter__') else [second_cup_x]
-
-        # Both should be valid lists
-        self.assertEqual(len(first_list), 2)
-        self.assertEqual(len(second_list), 2)
-
         # Values should be in valid range
-        for val in second_list:
-            self.assertGreaterEqual(val, 0.7)
-            self.assertLessEqual(val, 1.5)
+        self.assertGreaterEqual(first_cup_x, 0.7)
+        self.assertLessEqual(first_cup_x, 1.5)
+        self.assertGreaterEqual(second_cup_x, 0.7)
+        self.assertLessEqual(second_cup_x, 1.5)
 
     def test_main_script_scenario_should_convert_to_numpy_array(self):
         """Test that scenario values can be converted to numpy arrays."""
         # Pre-condition
         scenario_config = {
             "scenario": {
-                "cup_x": "${uniform: 0.7, 1.5}",
+                "cup_x": "${uniform_1d: 0.7, 1.5}",
             }
         }
         self.scenario.init(
-            run_id="run_id",
-            episode_id="episode_id",
             scenario=scenario_config,
-            seed=42,
-            num_env=2
+            seed=42
         )
 
         # In-test
-        cup_x = self.scenario.scenario.cup_x
+        resolved, _ = self.scenario.resolve()
+        cup_x = resolved.scenario.cup_x
         np_array = np.array(cup_x)
 
         # Post-condition
         self.assertIsInstance(np_array, np.ndarray)
-        self.assertEqual(len(np_array), 2)
 
         # Verify values are in expected range
-        for val in np_array:
+        for val in np.atleast_1d(np_array):
             self.assertGreaterEqual(val, 0.7)
             self.assertLessEqual(val, 1.5)
 
@@ -775,11 +676,8 @@ class ScenarioTest(unittest.TestCase):
             }
         }
         self.scenario.init(
-            run_id="run_id",
-            episode_id="episode_id",
             scenario=scenario_config,
-            seed=42,
-            num_env=2
+            seed=42
         )
 
         # In-test
@@ -793,8 +691,8 @@ class ScenarioTest(unittest.TestCase):
         self.assertIn("cup_x:", yaml_str)
         self.assertIn("cup_y:", yaml_str)
 
-    def test_main_script_scenario_should_handle_multiple_resets(self):
-        """Test multiple reset calls as shown in __main__ script."""
+    def test_main_script_scenario_should_handle_multiple_resolves(self):
+        """Test multiple resolve calls as shown in __main__ script."""
         # Pre-condition
         scenario_config = {
             "scenario": {
@@ -802,34 +700,26 @@ class ScenarioTest(unittest.TestCase):
             }
         }
         self.scenario.init(
-            run_id="run_id",
-            episode_id="episode_id",
             scenario=scenario_config,
-            seed=42,
-            num_env=2
+            seed=42
         )
 
-        first_values = list(self.scenario.scenario.cup_x)
+        resolved1, _ = self.scenario.resolve()
+        first_value = resolved1.scenario.cup_x
 
-        # In-test - First reset
-        self.scenario.reset()
-        second_values = list(self.scenario.scenario.cup_x)
+        # In-test - First resolve
+        resolved2, _ = self.scenario.resolve()
+        second_value = resolved2.scenario.cup_x
 
-        # In-test - Second reset
-        self.scenario.reset()
-        third_values = list(self.scenario.scenario.cup_x)
+        # In-test - Second resolve
+        resolved3, _ = self.scenario.resolve()
+        third_value = resolved3.scenario.cup_x
 
         # Post-condition
-        # All should be valid lists of size 2
-        self.assertEqual(len(first_values), 2)
-        self.assertEqual(len(second_values), 2)
-        self.assertEqual(len(third_values), 2)
-
         # All values should be in range
-        for vals in [first_values, second_values, third_values]:
-            for val in vals:
-                self.assertGreaterEqual(val, 0.7)
-                self.assertLessEqual(val, 1.5)
+        for val in [first_value, second_value, third_value]:
+            self.assertGreaterEqual(val, 0.7)
+            self.assertLessEqual(val, 1.5)
 
     def test_main_script_scenario_should_reinitialize_with_none(self):
         """Test reinitializing scenario with None as shown in __main__ script."""
@@ -840,11 +730,8 @@ class ScenarioTest(unittest.TestCase):
             }
         }
         self.scenario.init(
-            run_id="run_id",
-            episode_id="episode_id",
             scenario=scenario_config,
-            seed=42,
-            num_env=2
+            seed=42
         )
 
         # Verify initial scenario has content
@@ -853,8 +740,6 @@ class ScenarioTest(unittest.TestCase):
 
         # In-test - Reinitialize with None
         self.scenario.init(
-            run_id="run_id",
-            episode_id="episode_id",
             scenario=None,
             seed=42
         )
@@ -865,7 +750,7 @@ class ScenarioTest(unittest.TestCase):
         self.assertEqual(second_yaml.strip(), "{}")
 
     def test_main_script_scenario_should_handle_seed_consistency(self):
-        """Test that same seed produces consistent results across resets."""
+        """Test that same seed produces consistent results across resolves."""
         # Pre-condition
         scenario_config = {
             "scenario": {
@@ -877,26 +762,22 @@ class ScenarioTest(unittest.TestCase):
         # Create first scenario with seed
         scenario1 = Scenario()
         scenario1.init(
-            run_id="run_id",
-            episode_id="episode_id",
             scenario=scenario_config,
-            seed=42,
-            num_env=2
+            seed=42
         )
-        values1_x = list(scenario1.scenario.cup_x)
-        values1_y = list(scenario1.scenario.cup_y)
+        resolved1, _ = scenario1.resolve()
+        values1_x = resolved1.scenario.cup_x
+        values1_y = resolved1.scenario.cup_y
 
         # Create second scenario with same seed
         scenario2 = Scenario()
         scenario2.init(
-            run_id="run_id",
-            episode_id="episode_id",
             scenario=scenario_config,
-            seed=42,
-            num_env=2
+            seed=42
         )
-        values2_x = list(scenario2.scenario.cup_x)
-        values2_y = list(scenario2.scenario.cup_y)
+        resolved2, _ = scenario2.resolve()
+        values2_x = resolved2.scenario.cup_x
+        values2_y = resolved2.scenario.cup_y
 
         # Post-condition
         self.assertEqual(values1_x, values2_x)