keplemon 0.1.3__cp39-cp39-macosx_11_0_arm64.whl → 0.1.4__cp39-cp39-macosx_11_0_arm64.whl

keplemon/bodies.pyi

@@ -53,47 +53,134 @@ class Satellite:
     def get_state_at_epoch(self, epoch: Epoch) -> CartesianState: ...
 
 class Constellation:
+    """
+    Args:
+        name: Identifier of the constellation
+    """
+
     count: int
+    """Number of satellites in the constellation"""
+
     name: str | None
+    """Human-readable name of the constellation"""
+
     def __init__(self, name: str) -> None: ...
     @classmethod
-    def from_tle_catalog(cls, tle_catalog: TLECatalog) -> Constellation: ...
-    def get_states_at_epoch(self, epoch: Epoch) -> dict[int, CartesianState]: ...
+    def from_tle_catalog(cls, tle_catalog: TLECatalog) -> Constellation:
+        """
+        Instantiate a Constellation from a TLE catalog
+
+        Args:
+            tle_catalog: TLE catalog for the constellation
+        """
+        ...
+
+    def get_states_at_epoch(self, epoch: Epoch) -> dict[int, CartesianState]:
+        """
+        Args:
+            epoch: UTC epoch at which the states will be calculated
+
+        Returns:
+            (satellite_id, state) dictionary for the constellation at the given epoch
+        """
+        ...
+
     def get_ephemeris(
         self,
         start: Epoch,
         end: Epoch,
         step: TimeSpan,
-    ) -> dict[int, Ephemeris]: ...
+    ) -> dict[int, Ephemeris]:
+        """
+        Args:
+            start: UTC epoch of the start of the ephemeris
+            end: UTC epoch of the end of the ephemeris
+            step: Time step for the ephemeris
+
+        Returns:
+            (satellite_id, ephemeris) dictionary for the constellation
+        """
+        ...
+
     def get_ca_report_vs_one(
         self,
         other: Satellite,
         start: Epoch,
         end: Epoch,
         distance_threshold: float,
-    ) -> CloseApproachReport: ...
+    ) -> CloseApproachReport:
+        """
+        Calculate close approaches between the constellation and a given satellite.
+
+        Args:
+            other: Satellite to compare against
+            start: UTC epoch of the start of the close approach report
+            end: UTC epoch of the end of the close approach report
+            distance_threshold: Distance threshold for close approach screening in **_kilometers_**
+
+        Returns:
+            Close approach report for the constellation vs. the given satellite
+        """
+        ...
+
     def get_ca_report_vs_many(
         self,
         start: Epoch,
         end: Epoch,
         distance_threshold: float,
-    ) -> CloseApproachReport: ...
+    ) -> CloseApproachReport:
+        """
+        Calculate close approaches among satellites in the calling constellation.
+
+        !!! warning
+            This is a long-running operation when the constellation is large.
+
+        Args:
+            start: UTC epoch of the start of the close approach report
+            end: UTC epoch of the end of the close approach report
+            distance_threshold: Distance threshold for close approach screening in **_kilometers_**
+
+        Returns:
+            Close approach report for the constellation vs. all other satellites
+        """
+        ...
+
     def __getitem__(self, satellite_id: int) -> Satellite: ...
 
 class Sensor:
+    """
+    Args:
+        name: Identifier of the sensor
+        angular_noise: Angular noise in **_degrees_**
+    """
+
     name: str
     angular_noise: float
-    range_noise: float
-    range_rate_noise: float
-    angular_rate_noise: float
+    range_noise: float | None
+    """Range noise in **_kilometers_**"""
+
+    range_rate_noise: float | None
+    """Range rate noise in **_kilometers per second_**"""
+
+    angular_rate_noise: float | None
+    """Angular rate noise in **_degrees per second_**"""
     def __init__(self, name: str, angular_noise: float) -> None: ...
 
 class Observatory:
+    """
+    Args:
+        name: Identifier of the observatory
+        latitude: Latitude in **_degrees_**
+        longitude: Longitude in **_degrees_**
+        altitude: Altitude in **_kilometers_**
+    """
+
     name: str
     latitude: float
     longitude: float
     altitude: float
     sensors: list[Sensor]
+    """List of sensors at the observatory"""
     def __init__(
         self,
         name: str,
@@ -101,4 +188,12 @@ class Observatory:
         longitude: float,
         altitude: float,
     ) -> None: ...
-    def get_state_at_epoch(self, epoch: Epoch) -> CartesianState: ...
+    def get_state_at_epoch(self, epoch: Epoch) -> CartesianState:
+        """
+        Args:
+            epoch: UTC epoch of the state
+
+        Returns:
+            TEME Cartesian state of the observatory in **_kilometers_** and **_kilometers per second_**
+        """
+        ...

keplemon/elements.pyi

@@ -6,6 +6,16 @@ from keplemon.propagation import ForceProperties
 from keplemon.events import CloseApproach
 
 class KeplerianElements:
+    """
+    Args:
+        semi_major_axis: Average distance from the central body in **_kilometers_**
+        eccentricity: Eccentricity of the orbit
+        inclination: Inclination of the orbit in **_degrees_**
+        raan: Right Ascension of Ascending Node in **_degrees_**
+        argument_of_perigee: Argument of Perigee in **_degrees_**
+        mean_anomaly: Mean Anomaly in **_degrees_**
+    """
+
     semi_major_axis: float
     eccentricity: float
     inclination: float
@@ -25,46 +35,221 @@ class KeplerianElements:
 
 class TLE:
     satellite_id: int
-    designator: str
+    """"""
+
+    name: str
+    """"""
+
+    inclination: float
+    """Inclination of the orbit in **_degrees_**"""
+
+    eccentricity: float
+    """"""
+
+    raan: float
+    """Right Ascension of Ascending Node in **_degrees_**"""
+
+    argument_of_perigee: float
+    """Argument of Perigee in **_degrees_**"""
+
+    mean_anomaly: float
+    """Mean Anomaly in **_degrees_**"""
+
+    mean_motion: float
+    """Mean motion in **_revolutions per day_**"""
+
+    type: KeplerianType
+    """"""
+
+    b_star: float
+    """"""
+
+    mean_motion_dot: float
+    """"""
+
+    mean_motion_dot_dot: float
+    """"""
+
+    agom: float
+    """"""
+
+    b_term: float
+    """"""
+
+    epoch: Epoch
+    """UTC epoch of the state"""
+
     classification: Classification
-    keplerian_state: KeplerianState
-    force_properties: ForceProperties
-    ephemeris_type: KeplerianType
+    """"""
+
+    designator: str
+    """8-character identifier of the satellite"""
+
+    cartesian_state: CartesianState
+    """TEME cartesian state of the TLE at epoch"""
 
     @classmethod
-    def from_lines(cls, line_1: str, line_2: str, line_3: str | None = None) -> TLE: ...
-    def get_lines(self) -> tuple[str, str]: ...
-    def load_to_memory(self) -> None: ...
+    def from_lines(cls, line_1: str, line_2: str, line_3: str | None = None) -> TLE:
+        """
+        Create a TLE object using strings in 2 or 3 line format
+        """
+        ...
+
+    def get_lines(self) -> tuple[str, str]:
+        """
+        !!! note
+            If the TLE was created in the 3LE format, only lines 2 and 3 will be returned.  The name must be accessed
+            using the `name` property.
+
+        Returns:
+            Tuple of strings in 2 line format
+        """
+        ...
+
     def get_state_at_epoch(self, epoch: Epoch) -> CartesianState: ...
 
 class SphericalVector:
+    """
+    !!! note
+        The range units can be disregarded if this class is not being used for astrodynamic transforms.
+
+    Args:
+        range: distance from the origin in **_kilometers_**
+        right_ascension: right ascension in **_degrees_**
+        declination: declination in **_degrees_**
+    """
+
     range: float
     right_ascension: float
     declination: float
     def __init__(self, range: float, right_ascension: float, declination: float) -> None: ...
-    def to_cartesian(self) -> CartesianVector: ...
+    def to_cartesian(self) -> CartesianVector:
+        """
+        Returns:
+            Cartesian vector in **_kilometers_**.
+        """
+        ...
 
 class CartesianVector:
+    """
+    Args:
+        x: x coordinate
+        y: y coordinate
+        z: z coordinate
+    """
+
     x: float
     y: float
     z: float
     magnitude: float
+    """"""
+
     def __init__(self, x: float, y: float, z: float) -> None: ...
-    def distance(self, other: CartesianVector) -> float: ...
-    def to_spherical(self) -> SphericalVector: ...
+    def distance(self, other: CartesianVector) -> float:
+        """
+        !!! note
+            Take care to use consistent units with this function.
+
+        Returns:
+            Distance between two Cartesian vectors
+        """
+        ...
+
+    def to_spherical(self) -> SphericalVector:
+        """
+        Returns:
+            Spherical representation of the point
+        """
+        ...
+
     def __add__(self, other: CartesianVector) -> CartesianVector: ...
     def __sub__(self, other: CartesianVector) -> CartesianVector: ...
-    def angle(self, other: CartesianVector) -> float: ...
+    def angle(self, other: CartesianVector) -> float:
+        """
+        Returns:
+            Angle between two Cartesian vectors in **_radians_**.
+        """
+        ...
 
 class CartesianState:
+    """State represented as x, y, z and vx, vy, vz in a given reference frame.
+
+    Args:
+        epoch: UTC epoch of the state
+        position: Cartesian position vector in kilometers
+        velocity: Cartesian velocity vector in kilometers per second
+        frame: reference frame of the state
+    """
+
     position: CartesianVector
+    """Position of the state in kilometers"""
+
     velocity: CartesianVector
+    """Velocity of the state in kilometers per second"""
+
+    epoch: Epoch
+    """UTC epoch of the state"""
+
+    frame: ReferenceFrame
+    """Current reference frame of the state"""
+
+    def __init__(
+        self, epoch: Epoch, position: CartesianVector, velocity: CartesianVector, frame: ReferenceFrame
+    ) -> None: ...
+    def to_keplerian(self) -> KeplerianState:
+        """Convert the Cartesian state to osculating Keplerian elements"""
+        ...
+
+    def to_frame(self, frame: ReferenceFrame) -> CartesianState:
+        """
+
+        Args:
+            frame: reference frame of the output state
+
+        Returns:
+            CartesianState: Cartesian state in the new frame"""
+        ...
 
 class KeplerianState:
+    """Orbit represented as Keplerian elements in a given reference frame.
+
+    Args:
+        epoch: UTC epoch of the state
+        elements: Keplerian elements of the state
+        frame: reference frame of the state
+        keplerian_type: type of the Keplerian elements
+    """
+
     epoch: Epoch
-    elements: KeplerianElements
     frame: ReferenceFrame
-    keplerian_type: KeplerianType
+    type: KeplerianType
+    semi_major_axis: float
+    """Average distance from the central body in **_kilometers_**"""
+
+    eccentricity: float
+    """Eccentricity of the orbit"""
+
+    inclination: float
+    """Inclination of the orbit in **_degrees_**"""
+
+    raan: float
+    """Right Ascension of Ascending Node in **_degrees_**"""
+
+    argument_of_perigee: float
+    """Argument of Perigee in **_degrees_**"""
+
+    mean_anomaly: float
+    """Mean Anomaly in **_degrees_**"""
+
+    mean_motion: float
+    """Mean motion in **_revolutions per day_**"""
+
+    apoapsis: float
+    """Furthest point from the central body in **_kilometers_**"""
+
+    periapsis: float
+    """Closest point to the central body in **_kilometers_**"""
+
     def __init__(
         self,
         epoch: Epoch,
@@ -72,6 +257,21 @@ class KeplerianState:
         frame: ReferenceFrame,
         keplerian_type: KeplerianType,
     ) -> None: ...
+    def to_cartesian(self) -> CartesianState:
+        """
+        Returns:
+            Cartesian state in **_kilometers_** and **_kilometers per second_**.
+        """
+        ...
+
+    def to_frame(self, frame: ReferenceFrame) -> KeplerianState:
+        """
+        Args:
+            frame: reference frame of the output state
+
+        Returns:
+            Keplerian state in the new frame"""
+        ...
 
 class Ephemeris:
     def get_close_approach(
@@ -81,12 +281,33 @@ class Ephemeris:
     ) -> CloseApproach: ...
 
 class TopocentricElements:
+    """
+    Args:
+        ra: TEME right ascension in **_degrees_**
+        dec: TEME declination in **_degrees_**
+    """
+
     range: float | None
+    """Range in **_kilometers_**"""
+
     right_ascension: float
     declination: float
     range_rate: float | None
+    """Range rate in **_kilometers per second_**"""
+
     right_ascension_rate: float | None
+    """Right ascension rate in **_degrees per second**"""
+
     declination_rate: float | None
+    """Declination rate in **_degrees per second**"""
+
     def __init__(self, ra: float, dec: float) -> None: ...
     @classmethod
-    def from_j2000(cls, epoch: Epoch, ra: float, dec: float) -> TopocentricElements: ...
+    def from_j2000(cls, epoch: Epoch, ra: float, dec: float) -> TopocentricElements:
+        """
+        Args:
+            epoch: UTC epoch of the angles
+            ra: J2000 right ascension in **_degrees_**
+            dec: J2000 declination in **_degrees_**
+        """
+        ...

keplemon/estimation.pyi

@@ -6,8 +6,44 @@ from keplemon.enums import KeplerianType
 
 class Covariance:
     sigmas: list[float]
+    """"""
 
 class Observation:
+    """
+    Args:
+        sensor: Sensor that made the observation
+        epoch: Time of the observation
+        observed_teme_topo: Topocentric elements of the satellite at the time of observation
+        observer_teme_pos: Position of the observer in TEME coordinates
+    """
+
+    sensor: Sensor
+    """Sensor which produced the observation"""
+
+    epoch: Epoch
+    """Time the measurement was observed"""
+
+    range: float | None
+    """Observed range from the sensor to the satellite in **_kilometers_**"""
+
+    range_rate: float | None
+    """Observed range rate from the sensor to the satellite in **_kilometers per second_**"""
+
+    right_ascension: float
+    """Observed TEME right ascension in **_degrees_**"""
+
+    declination: float
+    """Observed TEME declination in **_degrees_**"""
+
+    right_ascension_rate: float | None
+    """Observed right ascension rate in **_degrees per second_**"""
+
+    declination_rate: float | None
+    """Observed declination rate in **_degrees per second_**"""
+
+    observed_satellite_id: int | None
+    """Tagged satellite ID of the observation"""
+
     def __init__(
         self,
         sensor: Sensor,
@@ -15,33 +51,122 @@ class Observation:
         observed_teme_topo: TopocentricElements,
         observer_teme_pos: CartesianVector,
     ) -> None: ...
-    def get_residual(self, sat: Satellite) -> ObservationResidual: ...
+    def get_residual(self, sat: Satellite) -> ObservationResidual | None:
+        """
+        Calculate the residual of the observation with respect to a given satellite state.
+
+        !!! note
+            If an error occurs during propagation of the satellite state, this method will return None.
+
+        Args:
+            sat: Expected satellite state
+
+        Returns:
+            Calculated residual
+        """
+        ...
 
 class ObservationResidual:
     range: float
+    """Euclidean distance between the observed and expected state in **_kilometers_**"""
+
     radial: float
+    """Radial distance between the observed and expected state in **_kilometers_**"""
+
     in_track: float
+    """In-track distance between the observed and expected state in **_kilometers_**"""
+
     cross_track: float
+    """Cross-track distance between the observed and expected state in **_kilometers_**"""
+
+    velocity: float
+    """Velocity magnitude difference between the observed and expected state in **_kilometers per second_**"""
+
+    radial_velocity: float
+    """Radial velocity difference between the observed and expected state in **_kilometers per second_**"""
+
+    in_track_velocity: float
+    """In-track velocity difference between the observed and expected state in **_kilometers per second_**"""
+
+    cross_track_velocity: float
+    """Cross-track velocity difference between the observed and expected state in **_kilometers per second_**"""
+
     time: float
+    """Time difference between the observed and expected state in **_seconds_**"""
+
     beta: float
+    """Out-of-plane difference between the observed and expected state in **_degrees_**"""
+
+    height: float
+    """Height difference between the observed and expected state in **_kilometers_**"""
 
 class BatchLeastSquares:
+    """
+    Args:
+        obs: List of observations to be used in the estimation
+        a_priori: A priori satellite state
+    """
+
     converged: bool
+    """Indicates if the solution meets the tolerance criteria"""
+
     max_iterations: int
+    """Maximum number of iterations to perform when solving if the tolerance is not met"""
+
     iteration_count: int
+    """Number of iterations performed to reach the solution"""
+
     current_estimate: Satellite
+    """Current estimate of the satellite state after iterating or solving"""
+
     rms: float | None
+    """Root mean square of the residuals in **_kilometers_**"""
+
     weighted_rms: float | None
+    """Unitless weighted root mean square of the residuals"""
+
     estimate_srp: bool
+    """Flag to indicate if solar radiation pressure should be estimated
+    
+    !!! warning
+        This currently has unexpected behavior if solving for output_types other than XP
+    """
+
     estimate_drag: bool
+    """Flag to indicate if atmospheric drag should be estimated
+    
+    !!! warning
+        This currently has unexpected behavior if solving for output_types other than XP
+    """
+
     a_priori: Satellite
+    """A priori satellite state used to initialize the estimation"""
+
     observations: list[Observation]
+    """List of observations used in the estimation"""
+
     residuals: list[tuple[Epoch, ObservationResidual]]
+    """List of residuals for each observation compared to the current estimate"""
+
     covariance: Covariance | None
+    """UVW covariance matrix of the current estimate in **_kilometers_** and **_kilometers per second_**"""
+
     output_type: KeplerianType
+    """Type of Keplerian elements to be used in the output state"""
+
     def __init__(
         self,
         obs: list[Observation],
         a_priori: Satellite,
     ) -> None: ...
-    def solve(self) -> None: ...
+    def solve(self) -> None:
+        """Iterate until the solution converges or the maximum number of iterations is reached."""
+        ...
+
+    def iterate(self) -> None:
+        """Perform a single iteration of the estimation process."""
+        ...
+
+    def reset(self) -> None:
+        """Reset the estimation process to the initial state."""
+        ...

keplemon/events.pyi

@@ -3,10 +3,27 @@ from keplemon.time import Epoch
 
 class CloseApproach:
     epoch: Epoch
+    """UTC epoch of the close approach"""
+
     primary_id: int
+    """Satellite ID of the primary body in the close approach"""
+
     secondary_id: int
+    """Satellite ID of the secondary body in the close approach"""
+
     distance: float
+    """Distance between the two bodies in **_kilometers_**"""
 
 class CloseApproachReport:
+    """
+    Args:
+        start: CA screening start time
+        end: CA screening end time
+        distance_threshold: Distance threshold for CA screening in **_kilometers_**
+    """
+
     close_approaches: list[CloseApproach]
+    """List of close approaches found during the screening"""
+
     distance_threshold: float
+    def __init__(self, start: Epoch, end: Epoch, distance_threshold: float) -> None: ...

keplemon/time.pyi

@@ -121,7 +121,7 @@ class TimeComponents:
     def to_iso(self) -> str:
         """
         Returns:
-            Epoch in ISO 8601 format (YYYY-MM-DDThh:mm:ss.sssZ)
+            Epoch in ISO 8601 format (YYYY-MM-DDThh:mm:ss.sss)
         """
         ...
 
@@ -129,7 +129,7 @@ class TimeComponents:
     def from_iso(cls, iso_str: str) -> TimeComponents:
         """
         Args:
-            iso_str: ISO 8601 formatted string (YYYY-MM-DDThh:mm:ss.sssZ)
+            iso_str: ISO 8601 formatted string (YYYY-MM-DDThh:mm:ss.sss)
         """
         ...
 
@@ -158,7 +158,7 @@ class Epoch:
     def from_iso(cls, iso_str: str, time_system: TimeSystem) -> Epoch:
         """
         Args:
-            iso_str: ISO 8601 formatted string (YYYY-MM-DDThh:mm:ss.sssZ)
+            iso_str: ISO 8601 formatted string (YYYY-MM-DDThh:mm:ss.sss)
             time_system: System used to calculate the epoch
         """
         ...
@@ -179,6 +179,7 @@ class Epoch:
 
         !!! note
             DTG formats include:
+
             - DTG 20: YYYY/DDD HHMM SS.SSS
             - DTG 19: YYYYMonDDHHMMSS.SSS
             - DTG 17: YYYY/DDD.DDDDDDDD
@@ -193,7 +194,7 @@ class Epoch:
     def to_iso(self) -> str:
         """
         Returns:
-            Epoch in ISO 8601 format (YYYY-MM-DDThh:mm:ss.sssZ)
+            Epoch in ISO 8601 format (YYYY-MM-DDThh:mm:ss.sss)
         """
         ...
 

keplemon-0.1.4.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: keplemon
+Version: 0.1.4
+Requires-Dist: requests
+Requires-Dist: click
+Requires-Dist: maturin ; extra == 'dev'
+Requires-Dist: keplemon[test] ; extra == 'dev'
+Requires-Dist: mkdocstrings[python] ; extra == 'dev'
+Requires-Dist: mkdocs-material ; extra == 'dev'
+Requires-Dist: markdown-include ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'test'
+Provides-Extra: dev
+Provides-Extra: test
+Summary: Citra Space Corporation's Rust-accelerated astrodynamics library.
+Author-email: Brandon Sexton <brandon@citra.space>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://keplemon.citra.space
+Project-URL: Repository, https://github.com/citra-space/keplemon.git
+Project-URL: Issues, https://github.com/citra-space/keplemon/issues
+
+# KepLemon
+
+[Citra Space Corporation's](https://citra.space) Rust-accelerated astrodynamics package built on the shared libraries
+provided by [space-track](https://space-track.org).  Please visit the [documentation](https://keplemon.citra.space)
+page for additional details.
+
+## Installation
+
+### From PyPI (Preferred)
+
+KepLemon can be installed directly for any operating system from a command line using `pip install keplemon`.
+
+### From a Local Build
+
+For python users, the **_preferred installation method is through [PyPI](https://www.pypi.org)_**; however, the package can be
+installed locally by following the steps below.
+
+1. `git clone https://github.com/citra-space/keplemon.git`
+2. `cargo install cargo-make`
+3. `cargo make build-<os>-<architecture>` (e.g. for Linux x86 `cargo make build-linux-amd`)
+4. `pip install target/wheels/*.whl`
+
+## Environment Settings
+
+Although not required, it is recommended to explicitly apply the settings in this section before using KepLemon to avoid
+unexpected behaviors and inaccurate calculations.
+
+### CPU Limits
+
+By default, KepLemon will have access to all available cores when performing parallel functions.  Limit this by calling
+`set_thread_count` **_before_** using other KepLemon functions.
+
+```python
+from keplemon import set_thread_count, get_thread_count
+
+# Update this to the desired core count
+set_thread_count(4)
+```
+
+### Time Constants and Earth-Orientation Parameters (EOP)
+
+All astrodynamics packages have a strict dependence on measured changes to time and Earth's orientation.  Since KepLemon
+uses the public Standardized Astrodynamics Algorithms Library (SAAL) at the core, the time and (EOP) data must conform
+to a specific format required by the underlying binaries.  Rather than referencing data directly provided by the
+[USNO](https://maia.usno.navy.mil/), utility scripts are provided in KepLemon to request and export the relevant data.
+
+#### Global Update
+
+Use the command below from a terminal to update time constants and EOP data package-wide.
+
+```bash
+keplemon --update-eop global
+```
+
+#### Local Override
+
+EOP data can also be written to explicit paths for inspection or package overrides using the commands below.
+
+```bash
+keplemon --update-eop custom_path.txt
+```
+
+!!! note
+    If you intend to use the data written to a local override, you must use the `load_time_constants` method at the
+    beginning of your scripts.  **_This is not needed if you maintain constants using the global method_**.
+
+```python
+from keplemon.time import load_time_constants
+
+# Update this to reflect the desired override path
+load_time_constants("custom_path.txt")
+```
+
+## Contributing
+
+Anyone is welcome to contribute to KepLemon.  Users are encouraged to start by opening issues or forking the repository.
+Changes directly to the baseline may be approved by contacting the owner at <brandon@citra.space>.
+

{keplemon-0.1.3.dist-info → keplemon-0.1.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
-keplemon-0.1.3.dist-info/METADATA,sha256=7XUC7UNKe-AvA8RBbhwVHBLQFpgfjMowCBbTca6K_vM,1116
-keplemon-0.1.3.dist-info/WHEEL,sha256=OWa2DoOWNAtKx8o8X2SfzZNCVYa4xySMUeG2PSXKaJ4,102
-keplemon-0.1.3.dist-info/entry_points.txt,sha256=eYbCkvQvWfRDQ0LzaCELov1xeLAxQEHlfdgNq-LXyb0,49
+keplemon-0.1.4.dist-info/METADATA,sha256=CXp2vu1v-VwHOi_vhjJEHvAXcGhgoIb0gxF1XGCrJUU,3711
+keplemon-0.1.4.dist-info/WHEEL,sha256=OWa2DoOWNAtKx8o8X2SfzZNCVYa4xySMUeG2PSXKaJ4,102
+keplemon-0.1.4.dist-info/entry_points.txt,sha256=eYbCkvQvWfRDQ0LzaCELov1xeLAxQEHlfdgNq-LXyb0,49
 keplemon/time.py,sha256=rFefwGP2deAeyzMQcaK5D7dIpiQDklr9eBKT6yVK7Ac,2872
 keplemon/enums.py,sha256=Jh0tFHg_rZXnOyLUXmHjSm3MSZFbvQKTBcP0BqHXeMY,308
 keplemon/events.py,sha256=Ep-X4WqhLtXue08swm6Whcc4VFzyWvqnjjAOov6M4bI,154
@@ -25,12 +25,12 @@ keplemon/assets/WGS84-70.GEO,sha256=ARjEC_5s2SVd0Kh9udbTy1ztBwTeuBYPOhUVJgIqit8,
 keplemon/assets/NWL8C-12.GEO,sha256=ZwDKiFC5AxrSIkDPBUnQMmZeSaA5272V-z8yn6bKjOs,4788
 keplemon/__main__.py,sha256=-3GVkDOA0lV0MIqU9gPb4zbVimg2lA8HMkvdPDw1O28,669
 keplemon/__init__.pyi,sha256=53luemEWRmxv8_3hkqme2Gp0bSwfkNuLgxxieU4XWdM,679
-keplemon/bodies.pyi,sha256=klIdvqJBvqB8mLoOwQnf1Ya_xzmfz3iN5jfbS5Hsgvw,2753
+keplemon/bodies.pyi,sha256=eIVIyUa9lCw4GAk_hKQsZJt-km0JCgibTY2K2Uy8niM,5453
 keplemon/catalogs.pyi,sha256=NlWv2E7g5JH8LZyyPCDe9Lh_Me5Fmpv3sPinnbJpLf8,524
-keplemon/elements.pyi,sha256=2rcN_JB2TGR47w0rBAZ-EsvNgKIvLIcJwxeo01cenMU,2718
+keplemon/elements.pyi,sha256=SHo2Xc7f7uLDbBGMYJ0HlqTbCjhXvyH4aW6835ARcIs,8046
 keplemon/enums.pyi,sha256=s9uqkm3Zrx6HLV4dQBScRiUy0CT4QoQwFjaCLOEMW1c,2330
-keplemon/estimation.pyi,sha256=Atm8uSJQUMDR95utj7_ULw1k-PdtkwSElG0oZmWrbqE,1215
-keplemon/events.pyi,sha256=sAn7JNeKJS6tM1kdegMIAwnq54reqLUD8-cScnYDzbA,248
+keplemon/estimation.pyi,sha256=zb_llx8pCx9Iv95mXXpGnXPZeJsg9Oh5GRWDLyXrMFI,5521
+keplemon/events.pyi,sha256=PrVNvvw1_BgUOIEPmxHE03-XTQcl3LTw8UeuRZOTha4,824
 keplemon/libastrofunc.dylib,sha256=UAf9ix55_mm1rvVCYHWTbuHvXPuZ673GfZsEqRknquc,241952
 keplemon/libdllmain.dylib,sha256=8-BkFlZIXC45mx5wPNq0JeEA3Coyqs5oKvcTPZBQC5g,112224
 keplemon/libelops.dylib,sha256=hzdkXXB582wBOBBJZa7gALMtB54sIwroEpgW-ol_EBI,92800
@@ -50,6 +50,6 @@ keplemon/libtle.dylib,sha256=GIGNJrqUqIzLTrNcUaC9yg94ZP53MZhClq4n7xvSdTk,164816
 keplemon/libvcm.dylib,sha256=c2x97IoW_cXq9kO1k56V1nTKXbnl812aZNKMPqKa6yU,196384
 keplemon/propagation.pyi,sha256=YSA3cBzgHLW3_dykrjMX4PbReYJmz5Z7bzfuibPaegc,464
 keplemon/saal.pyi,sha256=LX4i3SxpL6UduhHjJ5aO443QbH1v-BhKBL968Z8vQhY,469
-keplemon/time.pyi,sha256=iCKEf1j_lAsb9_OZ_3NgZUPBuF-bqnKxQkfrvZsHfGs,6258
-keplemon/_keplemon.cpython-39-darwin.so,sha256=WuaH7NKn3-2Y5Rlhxsl2tBDv2eU3-8BN3sFC7ScrNQU,1684544
-keplemon-0.1.3.dist-info/RECORD,,
+keplemon/time.pyi,sha256=f6MxNpscs3jje0zo5yilyMBj8b0U7TVFnU6bt6NAJl0,6255
+keplemon/_keplemon.cpython-39-darwin.so,sha256=y9ZVomoKDu72DFac75z8_UutJDy8SeekAzcNtOfrP_0,1684016
+keplemon-0.1.4.dist-info/RECORD,,

keplemon-0.1.3.dist-info/METADATA

@@ -1,28 +0,0 @@
-Metadata-Version: 2.4
-Name: keplemon
-Version: 0.1.3
-Requires-Dist: requests
-Requires-Dist: click
-Requires-Dist: maturin ; extra == 'dev'
-Requires-Dist: keplemon[test] ; extra == 'dev'
-Requires-Dist: mkdocstrings[python] ; extra == 'dev'
-Requires-Dist: mkdocs-material ; extra == 'dev'
-Requires-Dist: markdown-include ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'test'
-Provides-Extra: dev
-Provides-Extra: test
-Summary: Citra Space Corporation's Rust-accelerated astrodynamics library.
-Author-email: Brandon Sexton <brandon@citra.space>
-License: MIT
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Documentation, https://keplemon.citra.space
-Project-URL: Repository, https://github.com/citra-space/keplemon.git
-Project-URL: Issues, https://github.com/citra-space/keplemon/issues
-
-# KepLemon
-
-[Citra Space Corporation's](https://citra.space) Rust-accelerated astrodynamics package built on the shared libraries
-provided by [space-track](https://space-track.org).  Please visit the [documentation](https://keplemon.citra.space)
-page for additional details.
-