open-space-toolkit-physics 11.2.1__py313-none-manylinux2014_aarch64.whl

ostk/physics/test/time/test_date.py

@@ -0,0 +1,136 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.core.type import String
+
+from ostk.physics.time import Date
+
+
+def test_date_constructors():
+    assert Date(2018, 1, 1) is not None
+
+
+def test_date_undefined():
+    assert Date.undefined() is not None
+
+
+def test_date_J2000():
+    assert Date.J2000() is not None
+
+
+def test_date_GPS_epoch():
+    assert Date.GPS_epoch() is not None
+
+
+def test_date_unix_epoch():
+    assert Date.unix_epoch() is not None
+
+
+def test_date_modified_julian_date_epoch():
+    assert Date.modified_julian_date_epoch() is not None
+
+
+def test_date_parse():
+    ## Using python strings
+
+    # Testing with default format argument (Date::Format::Undefined)
+    date: Date = Date.parse("2018-01-01")
+
+    assert date is not None
+    assert isinstance(date, Date)
+    assert date.is_defined()
+
+    # Testing with Date.Format.Standard
+    date: Date = Date.parse("2018-01-01", Date.Format.Standard)
+
+    assert date is not None
+    assert isinstance(date, Date)
+    assert date.is_defined()
+
+    # Testing with Date.Format.STK
+    date: Date = Date.parse("2 Jan 2019", Date.Format.STK)
+
+    assert date is not None
+    assert isinstance(date, Date)
+    assert date.is_defined()
+
+    ## Using String class
+
+    # Testing with default format argument (Date::Format::Undefined)
+    date: Date = Date.parse(String("2018-01-01"))
+
+    assert date is not None
+    assert isinstance(date, Date)
+    assert date.is_defined()
+
+    # Testing with Date.Format.Standard
+    date: Date = Date.parse(String("2018-01-01"), Date.Format.Standard)
+
+    assert date is not None
+    assert isinstance(date, Date)
+    assert date.is_defined()
+
+    # Testing with Date.Format.STK
+    date: Date = Date.parse(String("2 Jan 2019"), Date.Format.STK)
+
+    assert date is not None
+    assert isinstance(date, Date)
+    assert date.is_defined()
+
+
+def test_date_operators():
+    date = Date(2018, 1, 1)
+
+    assert (date == date) is not None
+    assert (date != date) is not None
+
+
+def test_date_is_defined():
+    date = Date(2018, 1, 1)
+
+    assert date.is_defined() is not None
+
+
+def test_date_get_year():
+    date = Date(2018, 1, 1)
+
+    assert date.get_year() is not None
+
+
+def test_date_get_day():
+    date = Date(2018, 1, 1)
+
+    assert date.get_day() is not None
+
+
+def test_date_get_month():
+    date = Date(2018, 1, 1)
+
+    assert date.get_month() is not None
+
+
+def test_date_to_string():
+    date = Date(2018, 1, 1)
+
+    date.to_string()
+    date.to_string(Date.Format.Standard)
+    date.to_string(Date.Format.STK)
+
+
+def test_date_set_year():
+    date = Date(2018, 1, 1)
+
+    date.set_year(2019)
+
+
+def test_date_set_month():
+    date = Date(2018, 1, 1)
+
+    date.set_month(2)
+
+
+def test_date_set_day():
+    date = Date(2018, 1, 1)
+
+    date.set_day(2)

ostk/physics/test/time/test_date_time.py

@@ -0,0 +1,230 @@
+# Apache License 2.0
+
+import datetime
+
+from ostk.core.type import String
+
+from ostk.physics.time import Date
+from ostk.physics.time import Time
+from ostk.physics.time import DateTime
+
+
+class TestDateTime:
+    def test_constructor_success_full(self):
+        date_time = DateTime(
+            year=2020,
+            month=1,
+            day=1,
+            hour=0,
+            minute=0,
+            second=0,
+            millisecond=0,
+            microsecond=0,
+            nanosecond=0,
+        )
+
+        assert date_time is not None
+        assert isinstance(date_time, DateTime)
+        assert date_time.is_defined()
+
+    def test_constructor_success_partial(self):
+        date_time = DateTime(
+            year=2020,
+            month=1,
+            day=1,
+            hour=0,
+            minute=0,
+            second=0,
+        )
+
+        assert date_time is not None
+        assert isinstance(date_time, DateTime)
+        assert date_time.is_defined()
+
+    def test_constructor_success_date_time(self):
+        date_time = DateTime(
+            date=Date(2020, 1, 1),
+            time=Time(0, 0, 0),
+        )
+
+        assert date_time is not None
+        assert isinstance(date_time, DateTime)
+        assert date_time.is_defined()
+
+    # def test_constructor_success_python_datetime (self):
+
+    #     # date_time = DateTime(
+    #     #     datetime.datetime(2020, 1, 2, 3, 4, 5),
+    #     # )
+
+    #     # assert date_time is not None
+    #     # assert isinstance(date_time, DateTime)
+    #     # assert date_time.is_defined()
+
+    #     print(type(DateTime(2020, 1, 1)))
+    #     print(type(DateTime.J2000()))
+    #     print(type(DateTime(datetime.datetime.now())))
+
+    # datetime.datetime(date_time)
+
+    def test_comparators_success(self):
+        date_time_1 = DateTime(2020, 1, 1, 0, 0, 0, 0, 0, 0)
+        date_time_2 = DateTime(2020, 1, 1, 0, 0, 0, 0, 0, 1)
+        date_time_3 = DateTime(2020, 1, 1, 0, 0, 1, 0, 0, 0)
+
+        assert date_time_1 == date_time_1
+        assert date_time_2 == date_time_2
+        assert date_time_3 == date_time_3
+        assert date_time_1 != date_time_2
+        assert date_time_1 != date_time_3
+
+        date_time_1 = DateTime(2020, 1, 2, 3, 4, 5)
+        date_time_2 = datetime.datetime(2020, 1, 2, 3, 4, 5)
+
+        assert date_time_1 == date_time_1
+        assert date_time_1 == date_time_2
+        assert date_time_2 == date_time_2
+        assert (date_time_1 != date_time_1) is False
+
+    def test_is_defined_success(self):
+        date_time = DateTime(2018, 1, 1, 0, 0, 0, 0, 0, 0)
+
+        assert date_time is not None
+        assert date_time.is_defined()
+
+    def test_get_date_success(self):
+        date_time = DateTime(2018, 1, 1, 0, 0, 0, 0, 0, 0)
+
+        assert date_time.get_date() is not None
+        assert date_time.get_date() == Date(2018, 1, 1)
+
+    def test_get_time_success(self):
+        date_time = DateTime(2018, 1, 1, 0, 0, 0, 0, 0, 0)
+
+        assert date_time.get_time() is not None
+        assert date_time.get_time() == Time(0, 0, 0, 0, 0, 0)
+
+    def test_get_julian_date_success(self):
+        date_time = DateTime(2018, 1, 1, 0, 0, 0, 0, 0, 0)
+
+        assert date_time.get_julian_date()
+
+    def test_get_modified_julian_date_success(self):
+        date_time = DateTime(2018, 1, 1, 0, 0, 0, 0, 0, 0)
+
+        assert date_time.get_modified_julian_date()
+
+    def test_to_string_success(self):
+        date_time = DateTime(2018, 1, 1, 0, 0, 0, 0, 0, 0)
+
+        assert date_time.to_string()
+        assert date_time.to_string(DateTime.Format.Standard)
+        assert date_time.to_string(DateTime.Format.ISO8601)
+        assert date_time.to_string(DateTime.Format.STK)
+
+    def test_undefined_success(self):
+        assert DateTime.undefined() is None
+
+    def test_J2000_success(self):
+        date_time = DateTime.J2000()
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+
+    def test_GPS_epoch_success(self):
+        date_time = DateTime.GPS_epoch()
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+
+    def test_unix_epoch_success(self):
+        date_time = DateTime.unix_epoch()
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+
+    def test_modified_julian_date_epoch_success(self):
+        date_time = DateTime.modified_julian_date_epoch()
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+
+    def test_julian_date_success(self):
+        date_time = DateTime.julian_date(2458119.5)
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+
+    def test_modified_julian_date_success(self):
+        date_time = DateTime.modified_julian_date(58119.0)
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+
+    def test_parse_success_str_format_undefined(self):
+        date_time = DateTime.parse("2018-01-01 00:00:00")
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+        assert date_time == datetime.datetime(2018, 1, 1, 0, 0)
+        assert date_time == DateTime(2018, 1, 1, 0, 0, 0)
+
+    def test_parse_success_str_format_standard(self):
+        date_time = DateTime.parse("2018-01-01 00:00:00", DateTime.Format.Standard)
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+        assert date_time == datetime.datetime(2018, 1, 1, 0, 0)
+        assert date_time == DateTime(2018, 1, 1, 0, 0, 0)
+
+    def test_parse_success_str_format_iso8601(self):
+        date_time = DateTime.parse("2018-01-01T00:00:00", DateTime.Format.ISO8601)
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+        assert date_time == datetime.datetime(2018, 1, 1, 0, 0)
+        assert date_time == DateTime(2018, 1, 1, 0, 0, 0)
+
+    def test_parse_success_str_format_stk(self):
+        date_time = DateTime.parse("1 Jan 2018 00:00:00", DateTime.Format.STK)
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+        assert date_time == datetime.datetime(2018, 1, 1, 0, 0)
+        assert date_time == DateTime(2018, 1, 1, 0, 0, 0)
+
+    def test_parse_success_string_format_undefined(self):
+        date_time = DateTime.parse(String("2018-01-01 00:00:00"))
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+        assert date_time == datetime.datetime(2018, 1, 1, 0, 0)
+        assert date_time == DateTime(2018, 1, 1, 0, 0, 0)
+
+    def test_parse_success_string_format_standard(self):
+        date_time = DateTime.parse(
+            String("2018-01-01 00:00:00"), DateTime.Format.Standard
+        )
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+        assert date_time == datetime.datetime(2018, 1, 1, 0, 0)
+        assert date_time == DateTime(2018, 1, 1, 0, 0, 0)
+
+    def test_parse_success_string_format_iso8601(self):
+        date_time = DateTime.parse(String("2018-01-01T00:00:00"), DateTime.Format.ISO8601)
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+        assert date_time == datetime.datetime(2018, 1, 1, 0, 0)
+        assert date_time == DateTime(2018, 1, 1, 0, 0, 0)
+
+    def test_parse_success_string_format_stk(self):
+        date_time = DateTime.parse(String("1 Jan 2018 00:00:00"), DateTime.Format.STK)
+
+        assert date_time is not None
+        assert isinstance(date_time, datetime.datetime)
+        assert date_time == datetime.datetime(2018, 1, 1, 0, 0)
+        assert date_time == DateTime(2018, 1, 1, 0, 0, 0)
+
+        assert (datetime.datetime.now() + datetime.timedelta(days=1)) is not None

ostk/physics/test/time/test_duration.py

@@ -0,0 +1,215 @@
+# Apache License 2.0
+
+from datetime import timedelta
+
+from ostk.core.type import String
+
+from ostk.physics.unit import Time
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+
+
+class TestDuration:
+    def test_constructor_success_timedelta(self):
+        assert Duration(timedelta(days=123)).in_days() == 123.0
+        assert Duration(timedelta(hours=123)).in_hours() == 123.0
+        assert Duration(timedelta(minutes=123)).in_minutes() == 123.0
+        assert Duration(timedelta(seconds=123)).in_seconds() == 123.0
+        assert (
+            Duration(timedelta(seconds=123, microseconds=456000)).in_seconds() == 123.456
+        )
+        assert (
+            Duration(timedelta(seconds=123, microseconds=456)).in_seconds() == 123.000456
+        )
+        assert Duration(timedelta(microseconds=456000)).in_seconds() == 0.456
+        assert Duration(timedelta(microseconds=456)).in_seconds() == 0.000456
+
+    def test_operators_success(self):
+        duration_A = Duration.seconds(123.0)
+        duration_B = Duration.seconds(456.0)
+
+        assert (duration_A == duration_B) is not None
+        assert (duration_A != duration_B) is not None
+
+        assert (duration_A < duration_B) is not None
+        assert (duration_A <= duration_B) is not None
+        assert (duration_A > duration_B) is not None
+        assert (duration_A >= duration_B) is not None
+
+        assert (duration_A + duration_B) is not None
+        assert (duration_A - duration_B) is not None
+
+        assert (duration_A * 2.0) is not None
+        assert (duration_A / 2.0) is not None
+
+        duration_A += duration_B
+        duration_A -= duration_B
+
+        duration_A *= 2.0
+        duration_A /= 2.0
+
+    def test_is_defined_success(self):
+        assert Duration.seconds(123.0).is_defined() is not None
+
+    def test_is_zero_success(self):
+        assert Duration.seconds(123.0).is_zero() is not None
+
+    def test_is_positive_success(self):
+        assert Duration.seconds(123.0).is_positive() is not None
+
+    def test_is_strictly_positive_success(self):
+        assert Duration.seconds(123.0).is_strictly_positive() is not None
+
+    def test_is_near_success(self):
+        assert (
+            Duration.seconds(123.0).is_near(Duration.seconds(123.0), Duration.zero())
+            is not None
+        )
+
+    def test_get_nanoseconds_success(self):
+        assert Duration.seconds(123.0).get_nanoseconds() is not None
+
+    def test_get_microseconds_success(self):
+        assert Duration.seconds(123.0).get_microseconds() is not None
+
+    def test_get_milliseconds_success(self):
+        assert Duration.seconds(123.0).get_milliseconds() is not None
+
+    def test_get_seconds_success(self):
+        assert Duration.seconds(123.0).get_seconds() is not None
+
+    def test_get_minutes_success(self):
+        assert Duration.seconds(123.0).get_minutes() is not None
+
+    def test_get_hours_success(self):
+        assert Duration.seconds(123.0).get_hours() is not None
+
+    def test_get_days_success(self):
+        assert Duration.seconds(123.0).get_days() is not None
+
+    def test_get_weeks_success(self):
+        assert Duration.seconds(123.0).get_weeks() is not None
+
+    def test_in_nanoseconds_success(self):
+        assert Duration.seconds(123.0).in_nanoseconds() is not None
+
+    def test_in_microseconds_success(self):
+        assert Duration.seconds(123.0).in_microseconds() is not None
+
+    def test_in_milliseconds_success(self):
+        assert Duration.seconds(123.0).in_milliseconds() is not None
+
+    def test_in_seconds_success(self):
+        assert Duration.seconds(123.0).in_seconds() is not None
+
+    def test_in_minutes_success(self):
+        assert Duration.seconds(123.0).in_minutes() is not None
+
+    def test_in_hours_success(self):
+        assert Duration.seconds(123.0).in_hours() is not None
+
+    def test_in_days_success(self):
+        assert Duration.seconds(123.0).in_days() is not None
+
+    def test_in_weeks_success(self):
+        assert Duration.seconds(123.0).in_weeks() is not None
+
+    def test_in_unit_success(self):
+        assert Duration.seconds(123.0).in_unit(Time.Unit.Second) is not None
+
+    def test_get_absolute_success(self):
+        assert Duration.seconds(123.0).get_absolute() is not None
+
+    def test_to_string_success(self):
+        assert Duration.seconds(123.0).to_string() is not None
+        assert Duration.seconds(123.0).to_string(Duration.Format.Standard)
+        assert Duration.seconds(123.0).to_string(Duration.Format.ISO8601)
+
+    def test_to_timedelta_success(self):
+        assert isinstance(Duration.hours(1.0).to_timedelta(), timedelta)
+
+        assert Duration.seconds(0.0).to_timedelta() == timedelta(seconds=0.0)
+
+        assert Duration.nanoseconds(1.0).to_timedelta() == timedelta(microseconds=0.001)
+        assert Duration.microseconds(1.0).to_timedelta() == timedelta(microseconds=1.0)
+        assert Duration.seconds(1.0).to_timedelta() == timedelta(seconds=1.0)
+        assert Duration.minutes(1.0).to_timedelta() == timedelta(minutes=1.0)
+        assert Duration.hours(1.0).to_timedelta() == timedelta(hours=1.0)
+        assert Duration.days(1.0).to_timedelta() == timedelta(days=1.0)
+
+    def test_undefined_success(self):
+        assert Duration.undefined() is not None
+
+    def test_zero_success(self):
+        assert Duration.zero() is not None
+
+    def test_nanoseconds_success(self):
+        assert Duration.nanoseconds(123.456) is not None
+
+    def test_microseconds_success(self):
+        assert Duration.microseconds(123.456) is not None
+
+    def test_milliseconds_success(self):
+        assert Duration.milliseconds(123.456) is not None
+
+    def test_seconds_success(self):
+        assert Duration.seconds(123.456) is not None
+
+    def test_minutes_success(self):
+        assert Duration.minutes(123.456) is not None
+
+    def test_hours_success(self):
+        assert Duration.hours(123.456) is not None
+
+    def test_days_success(self):
+        assert Duration.days(123.456) is not None
+
+    def test_weeks_success(self):
+        assert Duration.weeks(123.456) is not None
+
+    def test_between_success(self):
+        assert Duration.between(Instant.now(), Instant.now()) is not None
+
+    def test_parse_success_python_str(self):
+        # Testing with default format argument (Duration::Format::Undefined)
+        duration = Duration.parse("02:03.456.000.000")
+
+        assert duration is not None
+        assert isinstance(duration, Duration)
+        assert duration.is_defined() is True
+
+        # Testing with Duration.Format.Standard
+        duration = Duration.parse("02:03.456.000.000", Duration.Format.Standard)
+
+        assert duration is not None
+        assert isinstance(duration, Duration)
+        assert duration.is_defined() is True
+
+        # Testing with Duration.Format.ISO8601
+        duration = Duration.parse("PT2M3.456S", Duration.Format.ISO8601)
+
+        assert duration is not None
+        assert isinstance(duration, Duration)
+        assert duration.is_defined() is True
+
+    def test_parse_success_string(self):
+        # Testing with default format argument (Duration::Format::Undefined)
+        duration = Duration.parse(String("02:03.456.000.000"))
+
+        assert duration is not None
+        assert isinstance(duration, Duration)
+        assert duration.is_defined() is True
+
+        # Testing with Duration.Format.Standard
+        duration = Duration.parse(String("02:03.456.000.000"), Duration.Format.Standard)
+
+        assert duration is not None
+        assert isinstance(duration, Duration)
+        assert duration.is_defined() is True
+
+        # Testing with Duration.Format.ISO8601
+        duration = Duration.parse(String("PT2M3.456S"), Duration.Format.ISO8601)
+
+        assert duration is not None
+        assert isinstance(duration, Duration)
+        assert duration.is_defined() is True

ostk/physics/test/time/test_instant.py

@@ -0,0 +1,103 @@
+# Apache License 2.0
+
+import datetime
+import pytest
+
+from ostk.physics.time import Scale
+from ostk.physics.time import Instant
+from ostk.physics.time import Duration
+from ostk.physics.time import DateTime
+
+
+def test_instant_undefined():
+    assert Instant.undefined() is not None
+
+
+def test_instant_now():
+    assert Instant.now() is not None
+
+
+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
+    )
+
+    assert Instant.date_time(datetime.datetime.now(), Scale.UTC)
+
+
+def test_instant_julian_date():
+    assert Instant.julian_date(2458119.5, Scale.UTC) is not None
+
+
+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()
+
+    assert (instant == instant) is not None
+    assert (instant != instant) is not None
+
+    assert (instant < instant) is not None
+    assert (instant <= instant) is not None
+    assert (instant > instant) is not None
+    assert (instant >= instant) is not None
+
+    assert (instant + Duration.seconds(1.0)) is not None
+    assert (instant - Duration.seconds(1.0)) is not None
+
+    assert (instant - instant) is not None
+
+    instant += Duration.seconds(1.0)
+    instant -= Duration.seconds(1.0)
+
+
+def test_instant_is_defined():
+    assert Instant.J2000().is_defined() is not None
+
+
+def test_instant_is_post_epoch():
+    assert Instant.J2000().is_post_epoch() is not None
+
+
+def test_instant_is_near():
+    assert Instant.J2000().is_near(Instant.J2000(), Duration.zero()) is not None
+
+
+def test_instant_get_date_time():
+    assert Instant.J2000().get_date_time(Scale.UTC) is not None
+
+
+def test_instant_get_julian_date():
+    assert Instant.J2000().get_julian_date(Scale.UTC) is not None
+
+
+def test_instant_get_modified_julian_date():
+    assert Instant.J2000().get_modified_julian_date(Scale.UTC) is not None
+
+
+def test_instant_to_string():
+    assert Instant.J2000().to_string() is not None
+    assert Instant.J2000().to_string(Scale.UTC) is not None
+    assert Instant.J2000().to_string(Scale.UTC, DateTime.Format.ISO8601) is not None