open-space-toolkit-astrodynamics 17.2.0__py312-none-manylinux2014_x86_64.whl

ostk/astrodynamics/test/test_access.py

@@ -0,0 +1,128 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+import ostk.mathematics as mathematics
+
+import ostk.physics as physics
+
+import ostk.astrodynamics as astrodynamics
+
+RealInterval = mathematics.object.RealInterval
+Quaternion = mathematics.geometry.d3.transformation.rotation.Quaternion
+Length = physics.unit.Length
+Angle = physics.unit.Angle
+DateTime = physics.time.DateTime
+Scale = physics.time.Scale
+Duration = physics.time.Duration
+Instant = physics.time.Instant
+Interval = physics.time.Interval
+Transform = physics.coordinate.Transform
+Frame = physics.coordinate.Frame
+Axes = physics.coordinate.Axes
+DynamicProvider = physics.coordinate.frame.provider.Dynamic
+Environment = physics.Environment
+Earth = physics.environment.object.celestial.Earth
+Trajectory = astrodynamics.Trajectory
+Profile = astrodynamics.flight.Profile
+Orbit = astrodynamics.trajectory.Orbit
+State = astrodynamics.trajectory.State
+Pass = astrodynamics.trajectory.orbit.Pass
+Kepler = astrodynamics.trajectory.orbit.model.Kepler
+COE = astrodynamics.trajectory.orbit.model.kepler.COE
+SGP4 = astrodynamics.trajectory.orbit.model.sgp4
+Access = astrodynamics.Access
+
+
+def test_access_constructors():
+    acquisition_of_signal = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    time_at_closest_approach = Instant.date_time(DateTime(2018, 1, 1, 0, 1, 0), Scale.UTC)
+    loss_of_signal = Instant.date_time(DateTime(2018, 1, 1, 0, 2, 0), Scale.UTC)
+    max_elevation = Angle.degrees(54.3)
+
+    access: Access = Access(
+        Access.Type.Complete,
+        acquisition_of_signal,
+        time_at_closest_approach,
+        loss_of_signal,
+        max_elevation,
+    )
+
+    assert access is not None
+    assert isinstance(access, Access)
+
+
+def test_access_undefined():
+    access: Access = Access.undefined()
+
+    assert access is not None
+    assert isinstance(access, Access)
+    assert access.is_defined() is False
+
+
+def test_access_getters():
+    acquisition_of_signal = Instant.date_time(DateTime(2018, 1, 1, 0, 0, 0), Scale.UTC)
+    time_at_closest_approach = Instant.date_time(DateTime(2018, 1, 1, 0, 1, 0), Scale.UTC)
+    loss_of_signal = Instant.date_time(DateTime(2018, 1, 1, 0, 2, 0), Scale.UTC)
+    max_elevation = Angle.degrees(54.3)
+
+    access: Access = Access(
+        Access.Type.Complete,
+        acquisition_of_signal,
+        time_at_closest_approach,
+        loss_of_signal,
+        max_elevation,
+    )
+
+    # get_type
+    access_type: Access.Type = access.get_type()
+
+    assert access_type is not None
+    assert isinstance(access_type, Access.Type)
+    assert access_type == Access.Type.Complete
+
+    # get_acquisition_of_signal
+    acq_signal: Instant = access.get_acquisition_of_signal()
+
+    assert acq_signal is not None
+    assert isinstance(acq_signal, Instant)
+    assert acq_signal == acquisition_of_signal
+
+    # get_time_of_closest_approach
+    closest_approach: Instant = access.get_time_of_closest_approach()
+
+    assert closest_approach is not None
+    assert isinstance(closest_approach, Instant)
+    assert closest_approach == time_at_closest_approach
+
+    # get_loss_of_signal
+    loss_signal: Instant = access.get_loss_of_signal()
+
+    assert loss_signal is not None
+    assert isinstance(loss_signal, Instant)
+    assert loss_signal == loss_of_signal
+
+    # get_interval
+    interval = access.get_interval()
+    assert interval is not None
+    assert isinstance(interval, Interval)
+
+    # get_duration
+    duration: Duration = access.get_duration()
+
+    assert duration is not None
+    assert isinstance(duration, Duration)
+
+    # get_max_elevation
+    max_el: Angle = access.get_max_elevation()
+
+    assert max_el is not None
+    assert isinstance(max_el, Angle)
+
+
+def test_access_string_from_type():
+    assert Access.string_from_type(Access.Type.Undefined) == "Undefined"
+    assert Access.string_from_type(Access.Type.Complete) == "Complete"
+    assert Access.string_from_type(Access.Type.Partial) == "Partial"

ostk/astrodynamics/test/test_converters.py

@@ -0,0 +1,290 @@
+# Apache License 2.0
+
+import pytest
+
+from datetime import datetime, timedelta, timezone
+
+from ostk.physics.time import Instant
+from ostk.physics.time import Interval
+from ostk.physics.time import DateTime
+from ostk.physics.time import Scale
+
+from ostk.astrodynamics.converters import coerce_to_datetime
+from ostk.astrodynamics.converters import coerce_to_instant
+from ostk.astrodynamics.converters import coerce_to_iso
+from ostk.astrodynamics.converters import coerce_to_interval
+
+
+def test_coerce_to_datetime_success_instant():
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC)
+    assert coerce_to_datetime(value) == datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc
+    )
+
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.TAI)
+    assert coerce_to_datetime(value) == datetime(
+        2020, 1, 2, 3, 3, 28, 123456, tzinfo=timezone.utc
+    )
+
+
+def test_coerce_to_datetime_success_datetime():
+    value = datetime(2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc)
+    assert coerce_to_datetime(value) == value
+
+    value = datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone(timedelta(seconds=3600))
+    )
+    assert coerce_to_datetime(value) == value
+
+
+def test_coerce_to_datetime_success_iso():
+    value = "2020-01-02T03:04:05.123456+00:00"
+    assert coerce_to_datetime(value) == datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc
+    )
+
+    value = "2020-01-02T03:04:05+00:00"
+    assert coerce_to_datetime(value) == datetime(2020, 1, 2, 3, 4, 5, tzinfo=timezone.utc)
+
+    value = "2020-01-02T03:04:05.123456+01:00"
+    assert coerce_to_datetime(value) == datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone(timedelta(seconds=3600))
+    )
+
+    value = "2020-01-02T03:04:05.123456Z"
+    assert coerce_to_datetime(value) == datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc
+    )
+
+    value = "2020-01-02T03:04:05Z"
+    assert coerce_to_datetime(value) == datetime(2020, 1, 2, 3, 4, 5, tzinfo=timezone.utc)
+
+
+def test_coerce_to_datetime_failure():
+    with pytest.raises(TypeError):
+        coerce_to_datetime(False)
+
+    with pytest.raises(Exception):
+        coerce_to_datetime("some_ill_formed_iso")
+
+
+def test_coerce_to_instant_success_datetime():
+    value = datetime(2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc)
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC
+    )
+
+    value = datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone(timedelta(seconds=3600))
+    )
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 2, 4, 5, 123, 456), Scale.UTC
+    )
+
+
+def test_coerce_to_instant_success_instant():
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC)
+    assert coerce_to_instant(value) == value
+
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.TAI)
+    assert coerce_to_instant(value) == value
+
+
+def test_coerce_to_instant_success_iso():
+    value = "2020-01-02T03:04:05.123456+00:00"
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC
+    )
+
+    value = "2020-01-02T03:04:05+00:00"
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 3, 4, 5), Scale.UTC
+    )
+
+    value = "2020-01-02T03:04:05.123456+01:00"
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 2, 4, 5, 123, 456), Scale.UTC
+    )
+
+    value = "2020-01-02T03:04:05.123456Z"
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC
+    )
+
+    value = "2020-01-02T03:04:05Z"
+    assert coerce_to_instant(value) == Instant.date_time(
+        DateTime(
+            2020,
+            1,
+            2,
+            3,
+            4,
+            5,
+        ),
+        Scale.UTC,
+    )
+
+
+def test_coerce_to_instant_failure():
+    with pytest.raises(TypeError):
+        coerce_to_instant(False)
+
+    with pytest.raises(Exception):
+        coerce_to_instant("some_ill_formed_iso")
+
+
+def test_coerce_to_iso_success_datetime():
+    value = datetime(2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc)
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123456+00:00"
+    )
+
+    value = datetime(
+        2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone(timedelta(seconds=3600))
+    )
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123456+01:00"
+    )
+
+    value = datetime(2020, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc)
+    assert (
+        coerce_to_iso(value, timespec="milliseconds") == "2020-01-02T03:04:05.123+00:00"
+    )
+
+    value = datetime(2020, 1, 2, 3, 4, 5, 0, tzinfo=timezone.utc)
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.000000+00:00"
+    )
+
+
+def test_coerce_to_iso_success_instant():
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC)
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123456+00:00"
+    )
+
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.TAI)
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:03:28.123456+00:00"
+    )
+
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123, 456), Scale.UTC)
+    assert (
+        coerce_to_iso(value, timespec="milliseconds") == "2020-01-02T03:04:05.123+00:00"
+    )
+
+    value = Instant.date_time(DateTime(2020, 1, 2, 3, 4, 5, 123), Scale.UTC)
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123000+00:00"
+    )
+
+
+def test_coerce_to_iso_success_iso():
+    value = "2020-01-02T03:04:05.123456+00:00"
+    assert coerce_to_iso(value, timespec="microseconds") == value
+
+    value = "2020-01-02T03:04:05.123456+01:00"
+    assert coerce_to_iso(value, timespec="microseconds") == value
+
+    value = "2020-01-02T03:04:05.123456+00:00"
+    assert (
+        coerce_to_iso(value, timespec="milliseconds") == "2020-01-02T03:04:05.123+00:00"
+    )
+
+    value = "2020-01-02T03:04:05.123+00:00"
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123000+00:00"
+    )
+
+    value = "2020-01-02T03:04:05+00:00"
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.000000+00:00"
+    )
+
+    value = "2020-01-02T03:04:05.123456Z"
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123456+00:00"
+    )
+
+    value = "2020-01-02T03:04:05.123456Z"
+    assert (
+        coerce_to_iso(value, timespec="milliseconds") == "2020-01-02T03:04:05.123+00:00"
+    )
+
+    value = "2020-01-02T03:04:05.123Z"
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.123000+00:00"
+    )
+
+    value = "2020-01-02T03:04:05Z"
+    assert (
+        coerce_to_iso(value, timespec="microseconds")
+        == "2020-01-02T03:04:05.000000+00:00"
+    )
+
+
+def test_coerce_to_iso_failure():
+    with pytest.raises(TypeError):
+        coerce_to_iso(False)
+
+    with pytest.raises(Exception):
+        coerce_to_iso("some_ill_formed_iso")
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        (
+            Interval.closed(
+                Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+                Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+            )
+        ),
+        (
+            (
+                Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+                Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+            )
+        ),
+        (
+            [
+                Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+                Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+            ]
+        ),
+        (
+            (
+                datetime(2020, 1, 1, tzinfo=timezone.utc),
+                datetime(2020, 1, 2, tzinfo=timezone.utc),
+            )
+        ),
+        (
+            [
+                datetime(2020, 1, 1, tzinfo=timezone.utc),
+                datetime(2020, 1, 2, tzinfo=timezone.utc),
+            ]
+        ),
+        (
+            [
+                "2020-01-01T00:00:00Z",
+                "2020-01-02T00:00:00Z",
+            ]
+        ),
+        ("[2020-01-01T00:00:00Z - 2020-01-02T00:00:00Z] [UTC]"),
+    ],
+)
+def test_coerce_to_interval(value):
+    assert coerce_to_interval(value) == Interval.closed(
+        Instant.date_time(DateTime(2020, 1, 1), Scale.UTC),
+        Instant.date_time(DateTime(2020, 1, 2), Scale.UTC),
+    )