{BugFix} Core - Apply timing naming conventions to PyBind tests

Summary:
Explanation:
This updates Project Aria Tools PyBind test and sample code so nanosecond timestamp local variables use explicit _ns names. The changed files cover the core Python binding examples and tests plus the Aria Digital Twin dataset tools Python binding test. Public API method names and external field names are unchanged.

Reproducibility:
- Verified with arc lint on the modified files.
- Local variable renames only; no behavior change.

Reviewed By: ksmdeepak

Differential Revision: D103541684

fbshipit-source-id: 329b4c21b69db510c86f0686c6c84e7454843084

Author: Misha Bolotski

core/python/TestBindings.py

@@ -282,15 +282,15 @@ def print_sample_random_access_image_data(provider, camera_name):
     option = (
         TimeQueryOptions.CLOSEST
     )  # get data whose time [in TimeDomain] is Closest to query time
-    start_time = provider.get_first_time_ns(sensor_stream_id, time_domain)
-    end_time = provider.get_last_time_ns(sensor_stream_id, time_domain)
-    for time in range(start_time, end_time, int(1e8)):
+    start_time_ns = provider.get_first_time_ns(sensor_stream_id, time_domain)
+    end_time_ns = provider.get_last_time_ns(sensor_stream_id, time_domain)
+    for time_ns in range(start_time_ns, end_time_ns, int(1e8)):
         image_data = provider.get_image_data_by_time_ns(
-            sensor_stream_id, time, time_domain, option
+            sensor_stream_id, time_ns, time_domain, option
         )
         pixel_format = image_data[0].get_pixel_format()
         print(
-            f"query time {time} and get image time {image_data[1].arrival_timestamp_ns} within range {start_time} {end_time} \n"
+            f"query time {time_ns} and get image time {image_data[1].arrival_timestamp_ns} within range {start_time_ns} {end_time_ns} \n"
             f"image pixel format is {pixel_format}"
         )
 
@@ -315,11 +315,11 @@ def print_sample_random_access_ppg_data(provider):
     option = (
         TimeQueryOptions.CLOSEST
     )  # get data whose time [in TimeDomain] is Closest to query time
-    start_time = provider.get_first_time_ns(ppg_stream_id, time_domain)
-    end_time = provider.get_last_time_ns(ppg_stream_id, time_domain)
-    for time in range(start_time, end_time, int(1e8)):
+    start_time_ns = provider.get_first_time_ns(ppg_stream_id, time_domain)
+    end_time_ns = provider.get_last_time_ns(ppg_stream_id, time_domain)
+    for time_ns in range(start_time_ns, end_time_ns, int(1e8)):
         ppg_data = provider.get_ppg_data_by_time_ns(
-            ppg_stream_id, time, time_domain, option
+            ppg_stream_id, time_ns, time_domain, option
         )
         print_ppg_data(ppg_data)
 
@@ -383,11 +383,11 @@ def print_sample_vio_data(provider):
     option = (
         TimeQueryOptions.CLOSEST
     )  # get data whose time [in TimeDomain] is Closest to query time
-    start_time = provider.get_first_time_ns(sensor_stream_id, time_domain)
-    end_time = provider.get_last_time_ns(sensor_stream_id, time_domain)
-    for time in range(start_time, end_time, int(1e8)):
+    start_time_ns = provider.get_first_time_ns(sensor_stream_id, time_domain)
+    end_time_ns = provider.get_last_time_ns(sensor_stream_id, time_domain)
+    for time_ns in range(start_time_ns, end_time_ns, int(1e8)):
         vioData = provider.get_vio_data_by_time_ns(
-            sensor_stream_id, time, time_domain, option
+            sensor_stream_id, time_ns, time_domain, option
         )
         print(
             f"Getting vio data from random accessor with timestamp {vioData.capture_timestamp_ns}, frame id is {vioData.frame_id}\n"

core/python/test/corePyBindTest.py

@@ -404,24 +404,24 @@ def test_random_accessor_timestamp(self) -> None:
                 ):
                     if not provider.supports_time_domain(stream_id, time_domain):
                         continue
-                    first_time = provider.get_first_time_ns(stream_id, time_domain)
-                    last_time = provider.get_last_time_ns(stream_id, time_domain)
-                    assert first_time <= last_time
-                    for time in range(first_time, last_time, int(1e8)):
-                        time_before = provider.get_sensor_data_by_time_ns(
-                            stream_id, time, time_domain, TimeQueryOptions.BEFORE
+                    first_time_ns = provider.get_first_time_ns(stream_id, time_domain)
+                    last_time_ns = provider.get_last_time_ns(stream_id, time_domain)
+                    assert first_time_ns <= last_time_ns
+                    for time_ns in range(first_time_ns, last_time_ns, int(1e8)):
+                        time_before_ns = provider.get_sensor_data_by_time_ns(
+                            stream_id, time_ns, time_domain, TimeQueryOptions.BEFORE
                         ).get_time_ns(time_domain)
-                        time_closest = provider.get_sensor_data_by_time_ns(
-                            stream_id, time, time_domain, TimeQueryOptions.CLOSEST
+                        time_closest_ns = provider.get_sensor_data_by_time_ns(
+                            stream_id, time_ns, time_domain, TimeQueryOptions.CLOSEST
                         ).get_time_ns(time_domain)
-                        time_after = provider.get_sensor_data_by_time_ns(
-                            stream_id, time, time_domain, TimeQueryOptions.AFTER
+                        time_after_ns = provider.get_sensor_data_by_time_ns(
+                            stream_id, time_ns, time_domain, TimeQueryOptions.AFTER
                         ).get_time_ns(time_domain)
-                        assert time_before <= time
-                        assert time_after >= time
-                        delta = abs(time_closest - time)
-                        assert delta <= (time_after - time) and delta <= (
-                            time - time_before
+                        assert time_before_ns <= time_ns
+                        assert time_after_ns >= time_ns
+                        delta = abs(time_closest_ns - time_ns)
+                        assert delta <= (time_after_ns - time_ns) and delta <= (
+                            time_ns - time_before_ns
                         )
 
     def test_random_accessor_timecode(self) -> None:
@@ -431,41 +431,45 @@ def test_random_accessor_timecode(self) -> None:
         for stream_id in streams:
             assert provider.supports_time_domain(stream_id, TimeDomain.TIME_CODE)
 
-            first_time = provider.get_first_time_ns(stream_id, TimeDomain.TIME_CODE)
-            last_time = provider.get_last_time_ns(stream_id, TimeDomain.TIME_CODE)
-            first_device_time = provider.convert_from_timecode_to_device_time_ns(
-                first_time
+            first_time_ns = provider.get_first_time_ns(stream_id, TimeDomain.TIME_CODE)
+            last_time_ns = provider.get_last_time_ns(stream_id, TimeDomain.TIME_CODE)
+            first_device_time_ns = provider.convert_from_timecode_to_device_time_ns(
+                first_time_ns
             )
-            first_device_time_compare = (
+            first_device_time_compare_ns = (
                 provider.convert_from_synctime_to_device_time_ns(
-                    first_time, TimeSyncMode.TIME_CODE
+                    first_time_ns, TimeSyncMode.TIME_CODE
                 )
             )
-            last_device_time = provider.convert_from_timecode_to_device_time_ns(
-                last_time
+            last_device_time_ns = provider.convert_from_timecode_to_device_time_ns(
+                last_time_ns
             )
-            last_device_time_compare = provider.convert_from_synctime_to_device_time_ns(
-                last_time, TimeSyncMode.TIME_CODE
+            last_device_time_compare_ns = (
+                provider.convert_from_synctime_to_device_time_ns(
+                    last_time_ns, TimeSyncMode.TIME_CODE
+                )
             )
-            assert first_device_time == first_device_time_compare
-            assert last_device_time == last_device_time_compare
-
-            assert first_time <= last_time
-            assert first_device_time <= last_device_time
-            for time in range(first_time, last_time, int(1e7)):
-                time_before = provider.get_sensor_data_by_time_ns(
-                    stream_id, time, TimeDomain.TIME_CODE, TimeQueryOptions.BEFORE
+            assert first_device_time_ns == first_device_time_compare_ns
+            assert last_device_time_ns == last_device_time_compare_ns
+
+            assert first_time_ns <= last_time_ns
+            assert first_device_time_ns <= last_device_time_ns
+            for time_ns in range(first_time_ns, last_time_ns, int(1e7)):
+                time_before_ns = provider.get_sensor_data_by_time_ns(
+                    stream_id, time_ns, TimeDomain.TIME_CODE, TimeQueryOptions.BEFORE
                 ).get_time_ns(TimeDomain.TIME_CODE)
-                time_closest = provider.get_sensor_data_by_time_ns(
-                    stream_id, time, TimeDomain.TIME_CODE, TimeQueryOptions.CLOSEST
+                time_closest_ns = provider.get_sensor_data_by_time_ns(
+                    stream_id, time_ns, TimeDomain.TIME_CODE, TimeQueryOptions.CLOSEST
                 ).get_time_ns(TimeDomain.TIME_CODE)
-                time_after = provider.get_sensor_data_by_time_ns(
-                    stream_id, time, TimeDomain.TIME_CODE, TimeQueryOptions.AFTER
+                time_after_ns = provider.get_sensor_data_by_time_ns(
+                    stream_id, time_ns, TimeDomain.TIME_CODE, TimeQueryOptions.AFTER
                 ).get_time_ns(TimeDomain.TIME_CODE)
-                assert time_before <= time
-                assert time_after >= time
-                delta = abs(time_closest - time)
-                assert delta <= (time_after - time) and delta <= (time - time_before)
+                assert time_before_ns <= time_ns
+                assert time_after_ns >= time_ns
+                delta = abs(time_closest_ns - time_ns)
+                assert delta <= (time_after_ns - time_ns) and delta <= (
+                    time_ns - time_before_ns
+                )
 
     def test_camera_calibration_rotation(self) -> None:
         provider = data_provider.create_vrs_data_provider(timecode_vrs_filepath)

projects/AriaDigitalTwinDatasetTools/python/TestBindings.py

@@ -90,9 +90,9 @@ def test_data_provider(self):
         self.assertTrue(maybe_first_image.is_valid())
         self.assertAlmostEqual(abs(maybe_first_image.dt_ns()), 0, 3)
         self.assertTrue(dp.get_aria_camera_calibration(stream_id))
-        first_tc_time = dp.get_timecode_from_device_time_ns(ts1)
+        first_tc_time_ns = dp.get_timecode_from_device_time_ns(ts1)
         self.assertTrue(
-            abs(ts1 - dp.get_device_time_from_timecode_ns(first_tc_time)) < 1000
+            abs(ts1 - dp.get_device_time_from_timecode_ns(first_tc_time_ns)) < 1000
         )
         self.assertTrue(dp.get_aria_3d_pose_by_timestamp_ns(ts1).is_valid())
         self.assertTrue(dp.get_object_3d_boundingboxes_by_timestamp_ns(ts1).is_valid())