open-space-toolkit-physics 11.3.0__py310-none-manylinux2014_aarch64.whl

ostk/physics/test/time/test_interval.py

@@ -0,0 +1,432 @@
+# Apache License 2.0
+
+import pytest
+
+from datetime import datetime
+
+from ostk.core.type import String
+
+from ostk.physics.time import Scale
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+from ostk.physics.time import Interval
+
+
+@pytest.fixture
+def closed_interval() -> Interval:
+    return Interval(
+        Instant.J2000(), Instant.J2000() + Duration.minutes(1.0), Interval.Type.Closed
+    )
+
+
+@pytest.fixture
+def open_interval() -> Interval:
+    return Interval(
+        Instant.J2000(), Instant.J2000() + Duration.minutes(1.0), Interval.Type.Open
+    )
+
+
+@pytest.fixture
+def half_open_right_interval() -> Interval:
+    return Interval(
+        Instant.J2000(),
+        Instant.J2000() + Duration.minutes(1.0),
+        Interval.Type.HalfOpenRight,
+    )
+
+
+@pytest.fixture
+def half_open_left_interval() -> Interval:
+    return Interval(
+        Instant.J2000(),
+        Instant.J2000() + Duration.minutes(1.0),
+        Interval.Type.HalfOpenLeft,
+    )
+
+
+@pytest.fixture
+def interval_1(closed_interval: Interval) -> Interval:
+    return closed_interval
+
+
+@pytest.fixture
+def interval_2() -> Interval:
+    return Interval(
+        Instant.J2000() - Duration.minutes(1.0), Instant.J2000(), Interval.Type.Closed
+    )
+
+
+@pytest.fixture
+def interval_3() -> Interval:
+    return Interval(
+        Instant.J2000() - Duration.minutes(2.0),
+        Instant.J2000() - Duration.minutes(1.0),
+        Interval.Type.Closed,
+    )
+
+
+@pytest.fixture
+def interval_4() -> Interval:
+    return Interval(
+        Instant.J2000(), Instant.J2000() + Duration.minutes(1.0), Interval.Type.Open
+    )
+
+
+@pytest.fixture
+def interval(interval_1: Interval) -> Interval:
+    return interval_1
+
+
+@pytest.fixture
+def instant_1() -> Interval:
+    return Instant.J2000()
+
+
+@pytest.fixture
+def instant_2() -> Interval:
+    return Instant.J2000() + Duration.seconds(30.0)
+
+
+@pytest.fixture
+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(
+            Instant.J2000(), Instant.J2000() + Duration.minutes(1.0), Interval.Type.Closed
+        )
+
+        assert interval is not None
+        assert isinstance(interval, Interval)
+
+        with pytest.raises(RuntimeError):
+            Interval(
+                Instant.J2000() + Duration.seconds(1.0),
+                Instant.J2000(),
+                Interval.Type.Closed,
+            )
+
+    def test_interval_undefined(self):
+        assert Interval.undefined() is not None
+        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
+        )
+
+    def test_interval_constructor_open(self):
+        assert (
+            Interval(
+                Instant.J2000(),
+                Instant.J2000() + Duration.minutes(1.0),
+                Interval.Type.Open,
+            )
+            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(
+                Instant.J2000(),
+                Instant.J2000() + Duration.minutes(1.0),
+                Interval.Type.HalfOpenLeft,
+            )
+            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(
+                Instant.J2000(),
+                Instant.J2000() + Duration.minutes(1.0),
+                Interval.Type.HalfOpenRight,
+            )
+            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(
+                Instant.J2000(), Duration.minutes(1.0), Interval.Type.Closed
+            )
+            is not None
+        )
+        assert (
+            Interval.centered(Instant.J2000(), Duration.minutes(1.0), Interval.Type.Open)
+            is not None
+        )
+        assert (
+            Interval.centered(
+                Instant.J2000(), Duration.minutes(1.0), Interval.Type.HalfOpenLeft
+            )
+            is not None
+        )
+        assert (
+            Interval.centered(
+                Instant.J2000(), Duration.minutes(1.0), Interval.Type.HalfOpenRight
+            )
+            is not None
+        )
+
+    def test_interval_operator_equality(self, interval_1: Interval, interval_4: Interval):
+        assert interval_1 == interval_1
+        assert (interval_1 != interval_1) is False
+
+        assert interval_1 != interval_4
+
+    def test_interval_is_defined(self, interval: Interval):
+        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.closed(Instant.J2000(), Instant.J2000()).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,
+        interval_1: Interval,
+        interval_2: Interval,
+        interval_3: Interval,
+        interval_4: Interval,
+    ):
+        assert interval_1.intersects(interval_1)
+        assert interval_1.intersects(interval_2)
+        assert interval_1.intersects(interval_3) is False
+        assert interval_1.intersects(interval_4)
+        assert interval_3.intersects(interval_4) is False
+        assert interval_3.intersects(interval_2)
+
+    def test_interval_contains_instant(
+        self,
+        interval_1: Interval,
+        interval_4: Interval,
+        instant_1: Instant,
+        instant_2: Instant,
+        instant_3: Instant,
+    ):
+        assert interval_1.contains_instant(instant_1)
+        assert interval_1.contains_instant(instant_2)
+        assert interval_1.contains_instant(instant_3) is False
+
+        assert interval_4.contains_instant(instant_1) is False
+        assert interval_4.contains_instant(instant_2)
+        assert interval_4.contains_instant(instant_3) is False
+
+    def test_interval_contains_interval(
+        self,
+        interval_1: Interval,
+        interval_2: Interval,
+        interval_3: Interval,
+        interval_4: Interval,
+    ):
+        assert interval_1.contains_interval(interval_1)
+        assert interval_1.contains_interval(interval_2) is False
+        assert interval_1.contains_interval(interval_3) is False
+        assert interval_1.contains_interval(interval_4)
+        assert interval_1.contains_interval(
+            Interval.closed(
+                Instant.J2000() + Duration.seconds(1.0),
+                Instant.J2000() + Duration.seconds(2.0),
+            )
+        )
+
+    def test_interval_get_properties(self, interval: Interval):
+        assert interval.get_start() == Instant.J2000()
+        assert interval.get_end() == Instant.J2000() + Duration.minutes(1.0)
+        assert interval.get_duration() == Duration.minutes(1.0)
+        assert interval.get_lower_bound() == interval.get_start()
+        assert interval.get_upper_bound() == interval.get_end()
+        assert interval.get_center() == Instant.J2000() + Duration.minutes(0.5)
+
+    def test_interval_to_string(self, interval: Interval):
+        assert interval.to_string() is not None
+        assert isinstance(interval.to_string(), String)
+        assert interval.to_string(Scale.UTC) is not None
+        assert isinstance(interval.to_string(Scale.UTC), String)
+
+    def test_interval_generate_grid(self, interval: Interval):
+        grid: list = interval.generate_grid(Duration.seconds(1.0))
+
+        assert grid is not None
+        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_scale.py

@@ -0,0 +1,11 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics.time import Scale
+
+
+def test_scale():
+    assert Scale.UTC is not None
+    assert Scale.TAI is not None
+    assert Scale.GPST is not None

ostk/physics/test/time/test_time.py

@@ -0,0 +1,114 @@
+# Apache License 2.0
+
+import pytest
+from ostk.core.type import String
+from ostk.physics.time import Time
+
+
+@pytest.fixture
+def time() -> Time:
+    return Time(0, 0, 0)
+
+
+class TestTime:
+    def test_constructors(self, time: Time) -> None:
+        assert time 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_operators(self, time: Time) -> None:
+        assert (time == time) is not None
+        assert (time != time) 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_get_minute(self, time: Time) -> None:
+        assert time.get_minute() 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_get_microsecond(self, time: Time) -> None:
+        assert time.get_microsecond() is not None
+
+    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_get_total_floating_seconds(self, time: Time) -> None:
+        assert time.get_total_floating_seconds() is not None
+
+    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_set_hour(self, time: Time) -> None:
+        time.set_hour(1)
+        assert time.get_hour() == 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_set_millisecond(self, time: Time) -> None:
+        time.set_millisecond(1)
+        assert time.get_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_undefined(self) -> None:
+        assert Time.undefined() is not None
+
+    def test_midnight(self) -> None:
+        assert Time.midnight() is not None
+
+    def test_noon(self) -> None:
+        assert Time.noon() is not None
+
+    def test_hours(self) -> None:
+        assert Time.hours(12.0345) is not None
+
+    def test_seconds(self) -> None:
+        assert Time.seconds(1238.0345) is not None

ostk/physics/test/unit/__init__.py

@@ -0,0 +1 @@
+# Apache License 2.0

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

@@ -0,0 +1 @@
+# Apache License 2.0