Revert changes that aren't related to moving pytest validations

Author: nycrat

src/software/ai/hl/stp/tactic/crease_defender/crease_defender_tactic_test.py

@@ -1,28 +1,12 @@
 import pytest
 import software.python_bindings as tbots_cpp
 
-from proto.import_all_protos import (
-    BallStealMode,
-    CreaseDefenderAlignment,
-    CreaseDefenderTactic,
-    MaxAllowedSpeedMode,
-)
-from proto.message_translation.tbots_protobuf import create_world_state
-from software.simulated_tests.validation.ball_is_off_ground import (
-    BallIsAlwaysOnGround,
-    BallIsEventuallyOffGround,
-)
-from software.simulated_tests.validation.excessive_dribbling import (
-    NeverExcessivelyDribbles,
-)
-from software.simulated_tests.validation.robot_enters_region import (
-    RobotEventuallyEntersRegion,
-    RobotNeverEntersRegion,
-)
 from proto.import_all_protos import *
-from software.simulated_tests.simulated_test_fixture import (
-    pytest_main,
-)
+from proto.message_translation.tbots_protobuf import create_world_state
+from software.simulated_tests.simulated_test_fixture import pytest_main
+from software.simulated_tests.validation.ball_is_off_ground import *
+from software.simulated_tests.validation.excessive_dribbling import *
+from software.simulated_tests.validation.robot_enters_region import *
 
 
 @pytest.mark.parametrize(

src/software/ai/hl/stp/tactic/goalie/goalie_tactic_test.py

@@ -1,7 +1,7 @@
 import pytest
 
 import software.python_bindings as tbots_cpp
-from proto.import_all_protos import GoalieTactic, MaxAllowedSpeedMode
+from proto.import_all_protos import *
 from software.simulated_tests.validation.robot_enters_region import *
 from software.simulated_tests.validation.ball_enters_region import *
 from software.simulated_tests.validation.ball_moves_in_direction import *

src/software/ai/hl/stp/tactic/pass_defender/pass_defender_tactic_test.py

@@ -1,7 +1,7 @@
 import pytest
 
 import software.python_bindings as tbots_cpp
-from proto.import_all_protos import PassDefenderTactic, BallStealMode
+from proto.import_all_protos import *
 from software.simulated_tests.validation.robot_enters_region import *
 from software.simulated_tests.validation.ball_enters_region import *
 from software.simulated_tests.validation.ball_moves_in_direction import *

src/software/python_bindings.cpp

@@ -152,7 +152,6 @@ PYBIND11_MODULE(python_bindings, m)
 
     py::class_<Vector>(m, "Vector")
         .def(py::init<float, float>())
-        .def_static("createFromAngle", &Vector::createFromAngle)
         .def("x", &Vector::x)
         .def("y", &Vector::y)
         .def("setX", &Vector::setX)

src/software/simulated_tests/simulated_test_fixture.py

@@ -18,13 +18,17 @@
 from software.thunderscope.binary_context_managers.game_controller import Gamecontroller
 from software.thunderscope.thunderscope_config import configure_simulated_test_view
 from software.thunderscope.thread_safe_buffer import ThreadSafeBuffer
-from software.thunderscope.constants import SimulatedTestConstants
 
 from software.logger.logger import create_logger
 from typing import override
 
 logger = create_logger(__name__)
 
+LAUNCH_DELAY_S = 0.1
+WORLD_BUFFER_TIMEOUT = 0.5
+PROCESS_BUFFER_DELAY_S = 0.01
+PAUSE_AFTER_FAIL_DELAY_S = 3
+
 
 class SimulatedTestRunner(TbotsTestRunner):
     """Run a simulated test"""
@@ -71,11 +75,11 @@ def excepthook(self, args):
 
         :param args: The args passed in from the hook
         """
-        self.__stopper(delay=SimulatedTestConstants.PAUSE_AFTER_FAIL_DELAY_S)
+        self.__stopper(delay=PAUSE_AFTER_FAIL_DELAY_S)
         self.last_exception = args.exc_value
         raise self.last_exception
 
-    def __stopper(self, delay=SimulatedTestConstants.PROCESS_BUFFER_DELAY_S):
+    def __stopper(self, delay=PROCESS_BUFFER_DELAY_S):
         """Stop running the test
 
         :param delay: How long to wait before closing everything, defaults
@@ -102,7 +106,7 @@ def sync_setup(self, setup, param):
 
             try:
                 world_state_received_buffer.get(
-                    block=True, timeout=SimulatedTestConstants.WORLD_BUFFER_TIMEOUT
+                    block=True, timeout=WORLD_BUFFER_TIMEOUT
                 )
             except queue.Empty:
                 # Did not receive a response within timeout period
@@ -162,19 +166,15 @@ def runner(
             while True:
                 try:
                     world = self.world_buffer.get(
-                        block=True,
-                        timeout=SimulatedTestConstants.WORLD_BUFFER_TIMEOUT,
-                        return_cached=False,
+                        block=True, timeout=WORLD_BUFFER_TIMEOUT, return_cached=False
                     )
 
                     # We block until the timeout for the new primitives from AI. if not found still,
                     # the SSL Wrapper packet is resent in a loop until we actually get a primitive set from AI
                     # Otherwise, if the AI misses the first SSL Wrapper packet and doesn't start
                     # the simulated test will continue to tick forward, causes syncing issues with the AI
                     self.primitive_set_buffer.get(
-                        block=True,
-                        timeout=SimulatedTestConstants.WORLD_BUFFER_TIMEOUT,
-                        return_cached=False,
+                        block=True, timeout=WORLD_BUFFER_TIMEOUT, return_cached=False
                     )
 
                     break
@@ -257,6 +257,7 @@ def run_test(
         always_validation_sequence_set,
         eventually_validation_sequence_set,
         test_timeout_s=3,
+        tick_duration_s=0.0166,  # Default to 60hz
         index=0,
         ci_cmd_with_delay=[],
         run_till_end=True,
@@ -267,6 +268,7 @@ def run_test(
         :param always_validation_sequence_set: validation that should always be true
         :param eventually_validation_sequence_set: validation that should eventually be true
         :param test_timeout_s: how long the test should run before timing out
+        :param tick_duration_s: length of a tick
         :param index: index of the current test. default is 0 (invariant test)
                       values can be passed in during aggregate testing for different timeout durations
         :param ci_cmd_with_delay: A list consisting of tuples with a duration and CI command, e.g.
@@ -293,7 +295,7 @@ def run_test(
                     always_validation_sequence_set,
                     eventually_validation_sequence_set,
                     test_timeout_duration,
-                    SimulatedTestConstants.TICK_DURATION_S,
+                    tick_duration_s,
                     ci_cmd_with_delay,
                     run_till_end,
                 ],
@@ -311,7 +313,7 @@ def run_test(
                 always_validation_sequence_set,
                 eventually_validation_sequence_set,
                 test_timeout_duration,
-                SimulatedTestConstants.TICK_DURATION_S,
+                tick_duration_s,
                 ci_cmd_with_delay=ci_cmd_with_delay,
                 run_till_end=run_till_end,
             )
@@ -530,29 +532,25 @@ def simulated_test_runner():
     test_name = current_test.split("-")[0]
 
     # Launch all binaries
-    with (
-        Simulator(
-            f"{args.simulator_runtime_dir}/test/{test_name}",
-            args.debug_simulator,
-            args.enable_realism,
-        ) as simulator,
-        FullSystem(
-            "software/unix_full_system",
-            f"{args.blue_full_system_runtime_dir}/test/{test_name}",
-            args.debug_blue_full_system,
-            False,
-            should_restart_on_crash=False,
-            running_in_realtime=args.enable_thunderscope,
-        ) as blue_fs,
-        FullSystem(
-            "software/unix_full_system",
-            f"{args.yellow_full_system_runtime_dir}/test/{test_name}",
-            args.debug_yellow_full_system,
-            True,
-            should_restart_on_crash=False,
-            running_in_realtime=args.enable_thunderscope,
-        ) as yellow_fs,
-    ):
+    with Simulator(
+        f"{args.simulator_runtime_dir}/test/{test_name}",
+        args.debug_simulator,
+        args.enable_realism,
+    ) as simulator, FullSystem(
+        "software/unix_full_system",
+        f"{args.blue_full_system_runtime_dir}/test/{test_name}",
+        args.debug_blue_full_system,
+        False,
+        should_restart_on_crash=False,
+        running_in_realtime=args.enable_thunderscope,
+    ) as blue_fs, FullSystem(
+        "software/unix_full_system",
+        f"{args.yellow_full_system_runtime_dir}/test/{test_name}",
+        args.debug_yellow_full_system,
+        True,
+        should_restart_on_crash=False,
+        running_in_realtime=args.enable_thunderscope,
+    ) as yellow_fs:
         with Gamecontroller(
             suppress_logs=(not args.show_gamecontroller_logs)
         ) as gamecontroller:
@@ -582,7 +580,7 @@ def simulated_test_runner():
                     layout_path=args.layout,
                 )
 
-            time.sleep(SimulatedTestConstants.LAUNCH_DELAY_S)
+            time.sleep(LAUNCH_DELAY_S)
 
             runner = None
 

src/software/simulated_tests/validation/validation.py

@@ -82,20 +82,23 @@ def flip_validation(self, world):
     # We simply pass the validation_geometry from the validation object through.
     common = {
         "__init__": constructor,
-        "get_validation_geometry": lambda self,
-        world: self.validation.get_validation_geometry(world),
+        "get_validation_geometry": lambda self, world: (
+            self.validation.get_validation_geometry(world)
+        ),
     }
 
     eventually_true = type(
         "EventuallyTrueValidation",
         (Validation,),
         {
             **common,
-            "__repr__": lambda self: "EventuallyTrueValidation: "
-            + repr(self.validation),
+            "__repr__": lambda self: (
+                "EventuallyTrueValidation: " + repr(self.validation)
+            ),
             "get_validation_type": lambda self: ValidationType.EVENTUALLY,
-            "get_validation_status": lambda self,
-            world: self.validation.get_validation_status(world),
+            "get_validation_status": lambda self, world: (
+                self.validation.get_validation_status(world)
+            ),
         },
     )
 
@@ -104,8 +107,9 @@ def flip_validation(self, world):
         (Validation,),
         {
             **common,
-            "__repr__": lambda self: "EventuallyFalseValidation: "
-            + repr(self.validation),
+            "__repr__": lambda self: (
+                "EventuallyFalseValidation: " + repr(self.validation)
+            ),
             "get_validation_type": lambda self: ValidationType.EVENTUALLY,
             "get_validation_status": lambda self, world: flip_validation(self, world),
         },
@@ -118,8 +122,9 @@ def flip_validation(self, world):
             **common,
             "__repr__": lambda self: "AlwaysTrueValidation: " + repr(self.validation),
             "get_validation_type": lambda self: ValidationType.ALWAYS,
-            "get_validation_status": lambda self,
-            world: self.validation.get_validation_status(world),
+            "get_validation_status": lambda self, world: (
+                self.validation.get_validation_status(world)
+            ),
         },
     )
 
@@ -137,44 +142,6 @@ def flip_validation(self, world):
     return eventually_true, eventually_false, always_true, always_false
 
 
-def create_validation_geometry(geometry=[]) -> ValidationGeometry:
-    """Creates a ValidationGeometry which is a visual representation of the
-    validation to be rendered as either green (PASSING) or red (FAILING)
-
-    Given a list of (vectors, polygons, circles), creates a ValidationGeometry
-    proto containing the protobuf representations.
-
-    :param geometry: A list of geom
-    :return: ValidationGeometry
-    """
-    validation_geometry = ValidationGeometry()
-
-    CREATE_PROTO_DISPATCH = {
-        tbots_cpp.Vector.__name__: tbots_cpp.createVectorProto,
-        tbots_cpp.Polygon.__name__: tbots_cpp.createPolygonProto,
-        tbots_cpp.Rectangle.__name__: tbots_cpp.createPolygonProto,
-        tbots_cpp.Circle.__name__: tbots_cpp.createCircleProto,
-        tbots_cpp.Segment.__name__: tbots_cpp.createSegmentProto,
-        tbots_cpp.Stadium.__name__: tbots_cpp.createStadiumProto,
-    }
-
-    ADD_TO_VALIDATION_GEOMETRY_DISPATCH = {
-        tbots_cpp.Vector.__name__: validation_geometry.vectors.append,
-        tbots_cpp.Polygon.__name__: validation_geometry.polygons.append,
-        tbots_cpp.Rectangle.__name__: validation_geometry.polygons.append,
-        tbots_cpp.Circle.__name__: validation_geometry.circles.append,
-        tbots_cpp.Segment.__name__: validation_geometry.segments.append,
-        tbots_cpp.Stadium.__name__: validation_geometry.stadiums.append,
-    }
-
-    for geom in geometry:
-        ADD_TO_VALIDATION_GEOMETRY_DISPATCH[type(geom).__name__](
-            CREATE_PROTO_DISPATCH[type(geom).__name__](geom)
-        )
-
-    return validation_geometry
-
-
 def run_validation_sequence_sets(
     world, eventually_validation_sequence_set, always_validation_sequence_set
 ):
@@ -248,6 +215,44 @@ def create_validation_proto_helper(validation_proto_set, validation):
     return eventually_validation_proto_set, always_validation_proto_set
 
 
+def create_validation_geometry(geometry=[]) -> ValidationGeometry:
+    """Creates a ValidationGeometry which is a visual representation of the
+    validation to be rendered as either green (PASSING) or red (FAILING)
+
+    Given a list of (vectors, polygons, circles), creates a ValidationGeometry
+    proto containing the protobuf representations.
+
+    :param geometry: A list of geom
+    :return: ValidationGeometry
+    """
+    validation_geometry = ValidationGeometry()
+
+    CREATE_PROTO_DISPATCH = {
+        tbots_cpp.Vector.__name__: tbots_cpp.createVectorProto,
+        tbots_cpp.Polygon.__name__: tbots_cpp.createPolygonProto,
+        tbots_cpp.Rectangle.__name__: tbots_cpp.createPolygonProto,
+        tbots_cpp.Circle.__name__: tbots_cpp.createCircleProto,
+        tbots_cpp.Segment.__name__: tbots_cpp.createSegmentProto,
+        tbots_cpp.Stadium.__name__: tbots_cpp.createStadiumProto,
+    }
+
+    ADD_TO_VALIDATION_GEOMETRY_DISPATCH = {
+        tbots_cpp.Vector.__name__: validation_geometry.vectors.append,
+        tbots_cpp.Polygon.__name__: validation_geometry.polygons.append,
+        tbots_cpp.Rectangle.__name__: validation_geometry.polygons.append,
+        tbots_cpp.Circle.__name__: validation_geometry.circles.append,
+        tbots_cpp.Segment.__name__: validation_geometry.segments.append,
+        tbots_cpp.Stadium.__name__: validation_geometry.stadiums.append,
+    }
+
+    for geom in geometry:
+        ADD_TO_VALIDATION_GEOMETRY_DISPATCH[type(geom).__name__](
+            CREATE_PROTO_DISPATCH[type(geom).__name__](geom)
+        )
+
+    return validation_geometry
+
+
 def check_validation(validation_proto_set):
     """Check validation and make sure its always true
 

src/software/thunderscope/constants.py

@@ -413,13 +413,3 @@ class RuntimeManagerConstants:
     RELEASES_URL = "https://api.github.com/repos/UBC-Thunderbots/Software/releases"
     DOWNLOAD_URL = "https://github.com/UBC-Thunderbots/Software/releases/download/"
     MAX_RELEASES_FETCHED = 5
-
-
-class SimulatedTestConstants:
-    """Constants for Simulated Tests"""
-
-    LAUNCH_DELAY_S = 0.1
-    WORLD_BUFFER_TIMEOUT = 0.5
-    PROCESS_BUFFER_DELAY_S = 0.01
-    PAUSE_AFTER_FAIL_DELAY_S = 3
-    TICK_DURATION_S = 0.0166  # 60 Hz