open-space-toolkit-physics 6.0.4__py311-none-manylinux2014_aarch64.whl → 11.3.0__py311-none-manylinux2014_aarch64.whl

ostk/physics/test/test_environment.py

@@ -12,68 +12,86 @@ def environment() -> Environment:
     return Environment.default()
 
 
-def test_environment_constructors():
-    instant = Instant.date_time(DateTime(2019, 1, 1, 0, 0, 0), Scale.UTC)
-    objects = []
+class TestEnvironment:
 
-    env: Environment = Environment(instant, objects)
+    def test_constructors(self):
+        instant = Instant.date_time(DateTime(2019, 1, 1, 0, 0, 0), Scale.UTC)
+        objects = []
 
-    assert env is not None
-    assert isinstance(env, Environment)
+        env: Environment = Environment(instant, objects)
 
+        assert env is not None
+        assert isinstance(env, Environment)
 
-def test_environment_undefined():
-    assert Environment.undefined() is not None
-    assert Environment.undefined().is_defined() is False
+        env = Environment(instant, objects, set_global_instance=True)
 
+        assert env is not None
+        assert isinstance(env, Environment)
 
-def test_environment_default():
-    assert Environment.default() is not None
+    def test_undefined(self):
+        assert Environment.undefined() is not None
+        assert Environment.undefined().is_defined() is False
 
+    def test_default(self):
+        assert Environment.default() is not None
+        assert Environment.default(set_global_instance=True) is not None
 
-def test_environment_isDefined(environment: Environment):
-    assert environment.is_defined() is not None
+    def test_is_defined(self, environment: Environment):
+        assert environment.is_defined() is not None
 
+    def test_has_object_with_name(self, environment: Environment):
+        assert environment.has_object_with_name("Earth") is not None
 
-def test_environment_has_object_with_name(environment: Environment):
-    assert environment.has_object_with_name("Earth") is not None
+    @pytest.mark.skip
+    def test_intersects(self, environment: Environment):
+        assert environment.intersects() is not None
 
+    def test_access_objects(self, environment: Environment):
+        assert environment.access_objects() is not None
 
-@pytest.mark.skip
-def test_environment_intersects(environment: Environment):
-    assert environment.intersects() is not None
+    def test_access_object_with_name(self, environment: Environment):
+        assert environment.access_object_with_name("Earth") is not None
 
+    def test_access_celestial_object_with_name(self, environment: Environment):
+        assert environment.access_celestial_object_with_name("Earth") is not None
 
-def test_environment_access_objects(environment: Environment):
-    assert environment.access_objects() is not None
+    def test_get_instant(self, environment: Environment):
+        assert environment.get_instant() is not None
 
+    def test_get_object_names(self, environment: Environment):
+        assert environment.get_object_names() is not None
 
-def test_environment_access_object_with_name(environment: Environment):
-    assert environment.access_object_with_name("Earth") is not None
-
-
-def test_environment_access_celestial_object_with_name(environment: Environment):
-    assert environment.access_celestial_object_with_name("Earth") is not None
+    def test_set_instant(self, environment: Environment):
+        environment.set_instant(
+            Instant.date_time(DateTime(2019, 1, 1, 0, 0, 0), Scale.UTC)
+        )
 
+    def test_is_position_in_eclipse(self, environment: Environment):
+        environment.set_instant(
+            Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+        )
 
-def test_environment_getInstant(environment: Environment):
-    assert environment.get_instant() is not None
+        assert environment.is_position_in_eclipse(
+            Position.meters(
+                [7000e3, 0.0, 0.0],
+                Frame.ITRF(),
+            )
+        )
 
+    def test_access_global_instance(self):
+        with pytest.raises(RuntimeError):
+            Environment.access_global_instance()
 
-def test_environment_get_object_names(environment: Environment):
-    assert environment.get_object_names() is not None
+        Environment.default(set_global_instance=True)
 
+        assert Environment.access_global_instance() is not None
 
-def test_environment_set_instant(environment: Environment):
-    environment.set_instant(Instant.date_time(DateTime(2019, 1, 1, 0, 0, 0), Scale.UTC))
+    def test_has_global_instance(self):
+        assert Environment.has_global_instance() is False
 
+        Environment.default(set_global_instance=True)
 
-def test_environment_is_position_in_eclipse(environment: Environment):
-    environment.set_instant(Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC))
+        assert Environment.has_global_instance() is True
 
-    assert environment.is_position_in_eclipse(
-        Position.meters(
-            [7000e3, 0.0, 0.0],
-            Frame.ITRF(),
-        )
-    )
+    def teardown_method(self, method):
+        Environment.reset_global_instance()

ostk/physics/test/time/test_duration.py

@@ -10,13 +10,6 @@ from ostk.physics.time import Duration
 
 
 class TestDuration:
-    def test_constructor_success_int(self):
-        assert Duration(0).in_seconds() == 0.0
-        assert Duration(int(-1e9)).in_seconds() == -1.0
-        assert Duration(int(+1e9)).in_seconds() == +1.0
-        assert Duration(-1e9).in_seconds() == -1.0
-        assert Duration(+1e9).in_seconds() == +1.0
-
     def test_constructor_success_timedelta(self):
         assert Duration(timedelta(days=123)).in_days() == 123.0
         assert Duration(timedelta(hours=123)).in_hours() == 123.0

ostk/physics/test/time/test_instant.py

@@ -21,6 +21,10 @@ def test_instant_J2000():
     assert Instant.J2000() is not None
 
 
+def test_instant_GPS_epock():
+    assert Instant.GPS_epoch() is not None
+
+
 def test_instant_datetime():
     assert (
         Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0, 0, 0, 0), Scale.UTC) is not None
@@ -37,6 +41,18 @@ def test_instant_modified_julian_date():
     assert Instant.modified_julian_date(58119.0, Scale.UTC) is not None
 
 
+def test_instant_parse():
+    assert Instant.parse("2024-01-01 00:01:02.000", Scale.UTC) is not None
+    assert (
+        Instant.parse("2024-01-01 00:01:02.000", Scale.UTC, DateTime.Format.Standard)
+        is not None
+    )
+    assert (
+        Instant.parse("2024-01-01T00:01:02.000", Scale.UTC, DateTime.Format.ISO8601)
+        is not None
+    )
+
+
 def test_instant_operators():
     instant = Instant.J2000()
 

ostk/physics/test/time/test_interval.py

@@ -2,6 +2,8 @@
 
 import pytest
 
+from datetime import datetime
+
 from ostk.core.type import String
 
 from ostk.physics.time import Scale
@@ -90,6 +92,16 @@ def instant_3() -> Interval:
     return Instant.J2000() + Duration.minutes(3.0)
 
 
+def build_interval(
+    offset_1: float, offset_2: float, type: Interval.Type = Interval.Type.Closed
+) -> Interval:
+    return Interval(
+        Instant.J2000() + Duration.seconds(offset_1),
+        Instant.J2000() + Duration.seconds(offset_2),
+        type,
+    )
+
+
 class TestInterval:
     def test_interval_constructor(self):
         interval: Interval = Interval(
@@ -111,6 +123,15 @@ class TestInterval:
         assert isinstance(Interval.undefined(), Interval)
 
     def test_interval_constructor_closed(self):
+        assert (
+            Interval(
+                Instant.J2000(),
+                Instant.J2000() + Duration.minutes(1.0),
+                Interval.Type.Closed,
+            )
+            is not None
+        )
+
         assert (
             Interval.closed(Instant.J2000(), Instant.J2000() + Duration.minutes(1.0))
             is not None
@@ -126,6 +147,11 @@ class TestInterval:
             is not None
         )
 
+        assert (
+            Interval.open(Instant.J2000(), Instant.J2000() + Duration.minutes(1.0))
+            is not None
+        )
+
     def test_interval_constructor_half_open_left(self):
         assert (
             Interval(
@@ -136,6 +162,13 @@ class TestInterval:
             is not None
         )
 
+        assert (
+            Interval.half_open_left(
+                Instant.J2000(), Instant.J2000() + Duration.minutes(1.0)
+            )
+            is not None
+        )
+
     def test_interval_constructor_half_open_right(self):
         assert (
             Interval(
@@ -146,6 +179,13 @@ class TestInterval:
             is not None
         )
 
+        assert (
+            Interval.half_open_right(
+                Instant.J2000(), Instant.J2000() + Duration.minutes(1.0)
+            )
+            is not None
+        )
+
     def test_interval_constructor_centered(self):
         assert (
             Interval.centered(
@@ -180,19 +220,15 @@ class TestInterval:
         assert interval.is_defined()
         assert Interval.undefined().is_defined() is False
 
-    def test_interval_is_degenerate(self, interval: Interval):
-        assert interval.is_degenerate() is False
-        assert Interval(Instant.J2000(), Instant.J2000()).is_degenerate()
-
     def test_interval_is_degenerate(self, interval: Interval):
         assert interval.is_degenerate() is False
         assert Interval.closed(Instant.J2000(), Instant.J2000()).is_degenerate()
-        assert Interval(
-            Instant.J2000(), Instant.J2000(), Interval.Type.Open
-        ).is_degenerate()
-        assert Interval.centered(
-            Instant.J2000(), Duration.minutes(0.0), Interval.Type.Open
-        ).is_degenerate()
+
+        with pytest.raises(Exception):
+            Interval(Instant.J2000(), Instant.J2000(), Interval.Type.Open).is_degenerate()
+            Interval.centered(
+                Instant.J2000(), Duration.minutes(0.0), Interval.Type.Open
+            ).is_degenerate()
 
     def test_interval_intersects(
         self,
@@ -263,3 +299,134 @@ class TestInterval:
         assert isinstance(grid, list)
         assert isinstance(grid[0], Instant)
         assert len(grid) == 61
+
+    def test_to_datetime_span(self, interval: Interval):
+        assert interval.to_datetime_span() is not None
+        assert isinstance(interval.to_datetime_span(), tuple)
+        assert isinstance(interval.to_datetime_span()[0], datetime)
+        assert isinstance(interval.to_datetime_span()[1], datetime)
+
+    def test_get_intersection_with(self):
+        intersection: Interval = build_interval(0.0, 10.0).get_intersection_with(
+            build_interval(5.0, 15.0)
+        )
+        assert isinstance(intersection, Interval)
+        assert intersection.is_defined()
+
+        intersection: Interval = build_interval(0.0, 10.0).get_intersection_with(
+            build_interval(20.0, 30.0)
+        )
+        assert isinstance(intersection, Interval)
+        assert not intersection.is_defined()
+
+    def test_get_union_with(self):
+        union: Interval = build_interval(0.0, 10.0).get_union_with(
+            build_interval(5.0, 15.0)
+        )
+        assert isinstance(union, Interval)
+        assert union.is_defined()
+
+        union: Interval = build_interval(0.0, 10.0).get_union_with(
+            build_interval(20.0, 30.0)
+        )
+        assert isinstance(union, Interval)
+        assert not union.is_defined()
+
+    def test_clip(self):
+        intervals: list[Interval] = [
+            build_interval(0.0, 10.0),
+            build_interval(20.0, 30.0),
+        ]
+
+        expected: list[Interval] = [
+            build_interval(5.0, 10.0),
+            build_interval(20.0, 25.0),
+        ]
+
+        assert Interval.clip(intervals, build_interval(5.0, 25.0)) == expected
+
+    def test_sort(self):
+        intervals: list[Interval] = [
+            build_interval(20.0, 30.0),
+            build_interval(0.0, 10.0),
+        ]
+
+        expected: list[Interval] = [
+            build_interval(0.0, 10.0),
+            build_interval(20.0, 30.0),
+        ]
+
+        assert Interval.sort(intervals) == expected
+
+    def test_merge(self):
+        intervals: list[Interval] = [
+            build_interval(20.0, 30.0),
+            build_interval(5.0, 15.0),
+            build_interval(0.0, 10.0),
+        ]
+
+        expected: list[Interval] = [
+            build_interval(0.0, 15.0),
+            build_interval(20.0, 30.0),
+        ]
+
+        assert Interval.merge(intervals) == expected
+
+    def test_get_gaps(self):
+        intervals: list[Interval] = [
+            build_interval(5.0, 10.0),
+            build_interval(20.0, 30.0),
+        ]
+
+        expected: list[Interval] = [
+            build_interval(10.0, 20.0, Interval.Type.Open),
+        ]
+
+        assert Interval.get_gaps(intervals) == expected
+
+        expected = [
+            build_interval(0.0, 5.0, Interval.Type.Open),
+            build_interval(10.0, 20.0, Interval.Type.Open),
+            build_interval(30.0, 35.0, Interval.Type.Open),
+        ]
+
+        assert (
+            Interval.get_gaps(intervals, build_interval(0.0, 35.0, Interval.Type.Open))
+            == expected
+        )
+
+    def test_logical_or(self):
+        intervals_1: list[Interval] = [
+            build_interval(0.0, 10.0),
+            build_interval(20.0, 30.0),
+        ]
+
+        intervals_2: list[Interval] = [
+            build_interval(5.0, 25.0),
+            build_interval(40.0, 50.0),
+        ]
+
+        expected: list[Interval] = [
+            build_interval(0.0, 30.0),
+            build_interval(40.0, 50.0),
+        ]
+
+        assert Interval.logical_or(intervals_1, intervals_2) == expected
+
+    def test_logical_and(self):
+        intervals_1: list[Interval] = [
+            build_interval(0.0, 10.0),
+            build_interval(20.0, 30.0),
+        ]
+
+        intervals_2: list[Interval] = [
+            build_interval(5.0, 25.0),
+            build_interval(40.0, 50.0),
+        ]
+
+        expected: list[Interval] = [
+            build_interval(5.0, 10.0),
+            build_interval(20.0, 25.0),
+        ]
+
+        assert Interval.logical_and(intervals_1, intervals_2) == expected

ostk/physics/test/time/test_time.py

@@ -1,170 +1,114 @@
 # Apache License 2.0
 
 import pytest
-
 from ostk.core.type import String
-
 from ostk.physics.time import Time
 
 
-def test_time_constructors():
-    assert Time(0, 0, 0) is not None
-
-
-def test_time_undefined():
-    assert Time.undefined() is not None
-
-
-def test_time_midnight():
-    assert Time.midnight() is not None
-
-
-def test_time_noon():
-    assert Time.noon() is not None
-
-
-def test_time_parse():
-    ## Using python strings
-
-    # Testing with default format argument (Time::Format::Undefined)
-    time: Time = Time.parse("00:00:00")
-
-    assert time is not None
-    assert isinstance(time, Time)
-    assert time.is_defined()
-
-    # Testing with Time.Format.Standard
-    time: Time = Time.parse("00:00:00", Time.Format.Standard)
-
-    assert time is not None
-    assert isinstance(time, Time)
-    assert time.is_defined()
-
-    # Testing with Time.Format.ISO8601
-    time: Time = Time.parse("00:00:00", Time.Format.ISO8601)
-
-    assert time is not None
-    assert isinstance(time, Time)
-    assert time.is_defined()
-
-    ## Using String class
-
-    # Testing with default format argument (Time::Format::Undefined)
-    time: Time = Time.parse(String("00:00:00"))
-
-    assert time is not None
-    assert isinstance(time, Time)
-    assert time.is_defined()
-
-    # Testing with Time.Format.Standard
-    time: Time = Time.parse(String("00:00:00"), Time.Format.Standard)
-
-    assert time is not None
-    assert isinstance(time, Time)
-    assert time.is_defined()
-
-    # Testing with Time.Format.ISO8601
-    time: Time = Time.parse(String("00:00:00"), Time.Format.ISO8601)
-
-    assert time is not None
-    assert isinstance(time, Time)
-    assert time.is_defined()
-
-
-def test_time_operators():
-    time = Time(0, 0, 0)
-
-    assert (time == time) is not None
-    assert (time != time) is not None
-
-
-def test_time_is_defined():
-    time = Time(0, 0, 0)
-
-    assert time.is_defined() is not None
-
-
-def test_time_get_hour():
-    time = Time(0, 0, 0)
-
-    assert time.get_hour() is not None
-
-
-def test_time_get_minute():
-    time = Time(0, 0, 0)
-
-    assert time.get_minute() is not None
-
-
-def test_time_get_second():
-    time = Time(0, 0, 0)
-
-    assert time.get_second() is not None
-
-
-def test_time_get_millisecond():
-    time = Time(0, 0, 0)
-
-    assert time.get_millisecond() is not None
-
-
-def test_time_get_microsecond():
-    time = Time(0, 0, 0)
-
-    assert time.get_microsecond() is not None
+@pytest.fixture
+def time() -> Time:
+    return Time(0, 0, 0)
 
 
-def test_time_get_nanosecond():
-    time = Time(0, 0, 0)
+class TestTime:
+    def test_constructors(self, time: Time) -> None:
+        assert time is not None
 
-    assert time.get_nanosecond() is not None
+    @pytest.mark.parametrize(
+        "time_string, format",
+        [
+            ("00:00:00", None),
+            ("00:00:00", Time.Format.Standard),
+            ("00:00:00", Time.Format.ISO8601),
+            (String("00:00:00"), None),
+            (String("00:00:00"), Time.Format.Standard),
+            (String("00:00:00"), Time.Format.ISO8601),
+        ],
+    )
+    def test_parse(self, time_string, format) -> None:
+        if format is None:
+            time = Time.parse(time_string)
+        else:
+            time = Time.parse(time_string, format)
 
+        assert time is not None
+        assert isinstance(time, Time)
+        assert time.is_defined()
 
-def test_time_get_floating_seconds():
-    time = Time(0, 0, 0)
+    def test_operators(self, time: Time) -> None:
+        assert (time == time) is not None
+        assert (time != time) is not None
 
-    assert time.get_floating_seconds() is not None
+    def test_is_defined(self, time: Time) -> None:
+        assert time.is_defined() is not None
 
+    def test_get_hour(self, time: Time) -> None:
+        assert time.get_hour() is not None
 
-def test_time_to_string():
-    time = Time(0, 0, 0)
+    def test_get_minute(self, time: Time) -> None:
+        assert time.get_minute() is not None
 
-    assert time.to_string() is not None
-    assert time.to_string(Time.Format.Standard) is not None
-    assert time.to_string(Time.Format.ISO8601) is not None
+    def test_get_second(self, time: Time) -> None:
+        assert time.get_second() is not None
 
+    def test_get_millisecond(self, time: Time) -> None:
+        assert time.get_millisecond() is not None
 
-def test_time_set_hour():
-    time = Time(0, 0, 0)
+    def test_get_microsecond(self, time: Time) -> None:
+        assert time.get_microsecond() is not None
 
-    time.set_hour(1)
+    def test_get_nanosecond(self, time: Time) -> None:
+        assert time.get_nanosecond() is not None
 
+    def test_get_floating_seconds(self, time: Time) -> None:
+        assert time.get_floating_seconds() is not None
 
-def test_time_set_minute():
-    time = Time(0, 0, 0)
+    def test_get_total_floating_seconds(self, time: Time) -> None:
+        assert time.get_total_floating_seconds() is not None
 
-    time.set_minute(1)
+    def test_get_total_floating_hours(self, time: Time) -> None:
+        assert time.get_total_floating_hours() is not None
 
+    def test_to_string(self, time: Time) -> None:
+        assert time.to_string() is not None
+        assert time.to_string(Time.Format.Standard) is not None
+        assert time.to_string(Time.Format.ISO8601) is not None
 
-def test_time_set_second():
-    time = Time(0, 0, 0)
+    def test_set_hour(self, time: Time) -> None:
+        time.set_hour(1)
+        assert time.get_hour() == 1
 
-    time.set_second(1)
+    def test_set_minute(self, time: Time) -> None:
+        time.set_minute(1)
+        assert time.get_minute() == 1
 
+    def test_set_second(self, time: Time) -> None:
+        time.set_second(1)
+        assert time.get_second() == 1
 
-def test_time_set_millisecond():
-    time = Time(0, 0, 0)
+    def test_set_millisecond(self, time: Time) -> None:
+        time.set_millisecond(1)
+        assert time.get_millisecond() == 1
 
-    time.set_millisecond(1)
+    def test_set_microsecond(self, time: Time) -> None:
+        time.set_microsecond(1)
+        assert time.get_microsecond() == 1
 
+    def test_set_nanosecond(self, time: Time) -> None:
+        time.set_nanosecond(1)
+        assert time.get_nanosecond() == 1
 
-def test_time_set_microsecond():
-    time = Time(0, 0, 0)
+    def test_undefined(self) -> None:
+        assert Time.undefined() is not None
 
-    time.set_microsecond(1)
+    def test_midnight(self) -> None:
+        assert Time.midnight() is not None
 
+    def test_noon(self) -> None:
+        assert Time.noon() is not None
 
-def test_time_set_nanosecond():
-    time = Time(0, 0, 0)
+    def test_hours(self) -> None:
+        assert Time.hours(12.0345) is not None
 
-    time.set_nanosecond(1)
+    def test_seconds(self) -> None:
+        assert Time.seconds(1238.0345) is not None

ostk/physics/test/unit/derived/test_angle.py

@@ -18,7 +18,7 @@ def test_angle_conversion():
 
     assert angle_physics is not None
     assert angle_mathematics is not None
-    # assert angle_physics == angle_mathematics
+    assert angle_physics == angle_mathematics
 
 
 def test_angle_unit():