satkit 0.2.8__tar.gz → 0.3.0__tar.gz

{satkit-0.2.8 → satkit-0.3.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satkit"
-version = "0.2.8"
+version = "0.3.0"
 edition = "2021"
 description = "Satellite Toolkit"
 readme = "README.md"
@@ -20,25 +20,25 @@ name = "satkit"
 
 
 [dependencies]
-nalgebra = "0.32.3"
+nalgebra = "0.33.0"
 ndarray = "0.15.6"
 libc = "0.2"
 chrono = "0.4.19"
 cty = "0.2.2"
 num-traits = "0.2"
 thiserror = "1.0"
-simba = "0.8"
+simba = "0.9"
 once_cell = "1.6.0"
 numpy = { version = "0.21.0", optional = true }
-pyo3 = { version = "0.21.0", features = ["extension-module"], optional = true }
+pyo3 = { version = "0.21", features = ["extension-module"], optional = true }
 ureq = "2.9.1"
 json = "0.12.4"
 process_path = "0.1.4"
 
 [build-dependencies]
 cc = { version = "1.0.74", features = ["parallel"] }
-chrono = "0.4.19"
-pyo3-build-config = { version = "0.21.0", optional = true }
+chrono = "0.4.38"
+pyo3-build-config = { version = "0.21", optional = true }
 
 [dev-dependencies]
 rand = "0.8.5"

{satkit-0.2.8/python/satkit.egg-info → satkit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.2.8
+Version: 0.3.0
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>

{satkit-0.2.8 → satkit-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "satkit"
-version = "0.2.8"
+version = "0.3.0"
 dependencies = ["numpy>=1.20.0"]
 requires-python = ">= 3.8"
 authors = [{ name = "Steven Michael", email = "ssmichael@gmail.com" }]

{satkit-0.2.8 → satkit-0.3.0}/python/docs/source/conf.py

@@ -77,8 +77,8 @@ github_project_url = "https://github.com/ssmichael1/satkit"
 ##version = "%i.%i" % version_ns["version_info"][:2]
 # The full version, including alpha/beta/rc tags.
 ##release = version_ns["__version__"]
-version = "0.2.7"
-release = "0.2.7"
+version = "0.2.9"
+release = "0.2.9"
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -162,7 +162,7 @@ html_theme = "sphinx_rtd_theme"
 # NOTE: Sphinx's 'make html' builder will throw a warning about an unfound
 #       _static directory. Do not remove or comment out html_static_path
 #       since it is needed to properly generate _static in the build directory
-html_static_path = ["source/_static"]
+html_static_path = ["_static"]
 
 # Add any extra paths that contain custom files (such as robots.txt or
 # .htaccess) here, relative to this directory. These files are copied
@@ -324,5 +324,5 @@ intersphinx_mapping = {
 spelling_lang = "en_US"
 spelling_word_list_filename = "spelling_wordlist.txt"
 
-primary_domain = "python"
+# primary_domain = "python"
 highlight_language = "python"

{satkit-0.2.8 → satkit-0.3.0}/python/satkit/__init__.pyi

@@ -8,6 +8,7 @@ from . import sun
 from . import satprop
 from . import density
 from . import utils
+from . import planets
 
 __all__ = [
     "time",
@@ -28,7 +29,9 @@ __all__ = [
     "utils",
     "moon",
     "sun",
+    "planets",
     "satprop",
+    "satstate",
     "density",
-    "utils"
+    "utils",
 ]

{satkit-0.2.8 → satkit-0.3.0}/python/satkit/density.pyi

@@ -22,22 +22,16 @@ def nrlmsise(itrf: satkit.itrfcoord, time: satkit.time | None) -> typing.Tuple[f
     or for more detail:
     https://agupubs.onlinelibrary.wiley.com/doi/full/10.1029/2002JA009430
     
-    Inputs: 
+    Args: 
     
-        itrf:  satkit.itrfcoord representing position at which to 
-                compute density & temperature
-                  
-        time:  Optional instant at which to compute density & temperature.
+        itrf (satkit.itrfcoord):  position at which to compute density & temperature                  
+        time (satkit.time|numpy.ndarray|list):  Optional instant(s) at which to compute density & temperature.
                "Space weather" data at this time will be used in model 
                computation.  Note: at satellite altitudes, density can
                change by > 10 X depending on solar cycle
                  
-    Outputs:
-        
-        rho:  Atmosphere mass density in kg / m^3
-        
-          T:  Atmosphere temperature in Kelvin
-    
+    Returns:
+        tuple: (rho, T) where rho is mass density in kg/m^3 and T is temperature in Kelvin
     """
     
 @typing.overload
@@ -53,22 +47,15 @@ def nrlmsise(altitude_meters: float,
     or for more detail:
     https://agupubs.onlinelibrary.wiley.com/doi/full/10.1029/2002JA009430
     
-    Inputs: 
-    
-    altitude_meters:  Altitude in meters
-    
-       latitude_rad:  Latitude in radians
-       
-      longitude_rad:  Longitude in radians
+    Args:
+        altitude_meters (float):  Altitude in meters
+        latitude_rad (float, optional):  Latitude in radians. Default is 0.
+        longitude_rad (float, optional):  Longitude in radians.  Default is 0.
+        time (satkit.time|numpy.ndarray|list, optional):  Optional instant(s) at which to compute density & temperature.
+               "Space weather" data at this time will be used in model 
+               computation.  Note: at satellite altitudes, density can
+               change by > 10 X depending on solar cycle
                  
-               time:  Optional instant at which to compute density & temperature.
-                      "Space weather" data at this time will be used in model 
-                      computation.  Note: at satellite altitudes, density can
-                      change by > 10 X depending on solar cycle                 
-    Outputs:
-        
-        rho:  Atmosphere mass density in kg / m^3
-        
-          T:  Atmosphere temperature in Kelvin
-    
+    Returns:
+        tuple: (rho, T) where rho is mass density in kg/m^3 and T is temperature in Kelvin
     """

{satkit-0.2.8 → satkit-0.3.0}/python/satkit/jplephem.pyi

@@ -1,7 +1,7 @@
 """
 High-precision JPL ephemerides for solar-system bodies
 
-For details, see:
+For details, see: https://ssd.jpl.nasa.gov/
 """
 
 from __future__ import annotations

satkit-0.3.0/python/satkit/planets.pyi

@@ -0,0 +1,28 @@
+"""
+Low-precision planetary ephemerides from https://ssd.jpl.nasa.gov/?planet_pos
+"""
+
+from __future__ import annotations
+import typing
+import numpy.typing as npt
+import numpy as np
+
+import satkit
+
+def heliocentric_pos(body: satkit.solarsystem, tm: satkit.time|list[satkit.time]|npt.ArrayLike[satkit.time]) -> npt.ArrayLike[np.float64]:
+    """Return the position of the given body in the Heliocentric coordinate system (origin is the Sun)
+    
+    Note: This function is only valid for the Sun and the 8 planets
+
+    Note: This is less accurate than using the jpl ephemeris, but involves fewer calculations
+    
+    Note: See https://ssd.jpl.nasa.gov/?planet_pos for more information and accuracy details
+
+    Args:
+        body (satkit.solarsystem): Solar system body for which to return position
+        tm (satkit.time|numpy.ndarray|list): Time[s] at which to return position
+    
+    Returns:
+        numpy.ndarray: 3-vector of Cartesian position in meters, with the origin at the Sun. 
+                       If input is list or numpy array of N times, then r will be Nx3 array
+    """

{satkit-0.2.8 → satkit-0.3.0}/python/satkit/satkit.pyi

@@ -454,15 +454,17 @@ class time:
     
     Notes:
         * If no arguments are passed in, the created object represents the current time
-    
+        * If year is passed in, month and day must also be passed in
+        * If hour is passed in, minute and second must also be passed in
+
     Args:
-        year (int): Gregorian year (e.g., 2024) (optional)
-        month (int): Gregorian month (1 = January, 2 = February, ...) (optional)
-        day (int): Day of month, beginning with 1 (optional)
-        hour (int): Hour of day, in range [0,23] (optional), default is 0
-        min (int): Minute of hour, in range [0,59] (optional), default is 0
-        sec (float): floating point second of minute, in range [0,60) (optional), defialt is 0
-        scale (satkit.timescale): Time scale (optional), default is satkit.timescale.UTC    
+        year (int, optional): Gregorian year (e.g., 2024)
+        month (int, optional): Gregorian month (1 = January, 2 = February, ...)
+        day (int, optional): Day of month, beginning with 1
+        hour (int, optional): Hour of day, in range [0,23] (optional), default is 0
+        min (int, optional): Minute of hour, in range [0,59], default is 0
+        sec (float, optional): floating point second of minute, in range [0,60), default is 0
+        scale (satkit.timescale, optional): Time scale , default is satkit.timescale.UTC    
     
     Returns:
         satkit.time: Time object representing input date and time, or if no arguments, the current date and time
@@ -488,13 +490,13 @@ class time:
             * If no arguments are passed in, the created object represents the current time
         
         Args:
-            year (int): Gregorian year (e.g., 2024) (optional)
-            month (int): Gregorian month (1 = January, 2 = February, ...) (optional)
-            day (int): Day of month, beginning with 1 (optional)
-            hour (int): Hour of day, in range [0,23] (optional), default is 0
-            min (int): Minute of hour, in range [0,59] (optional), default is 0
-            sec (float): floating point second of minute, in range [0,60) (optional), defialt is 0
-            scale (satkit.timescale): Time scale (optional), default is satkit.timescale.UTC    
+            year (int, optional): Gregorian year (e.g., 2024)
+            month (int, optional): Gregorian month (1 = January, 2 = February, ...)
+            day (int, optional): Day of month, beginning with 1
+            hour (int, optional): Hour of day, in range [0,23] (optional), default is 0
+            min (int, optional): Minute of hour, in range [0,59], default is 0
+            sec (float, optional): floating point second of minute, in range [0,60), default is 0
+            scale (satkit.timescale, optional): Time scale , default is satkit.timescale.UTC   
         
         Returns:
             satkit.time: Time object representing input date and time, or if no arguments, the current date and time
@@ -541,6 +543,17 @@ class time:
             satkit.time: Time object representing input Julian date and time scale
         """
 
+    @staticmethod
+    def from_unixtime(ut: float) -> time:
+        """Return a time object representing input unixtime
+        
+        Args:
+            ut (float): unixtime, UTC seconds since Jan 1, 1970 00:00:00
+
+        Returns:
+            satkit.time: Time object representing input unixtime
+        """
+
     @staticmethod
     def from_mjd(mjd: float, scale: timescale = timescale.UTC) -> time:
         """Return a time object representing input modified Julian date and time scale
@@ -1073,6 +1086,16 @@ class kepler:
             argp (float) : Argument of perigee, radians
             nu (float) : True anomaly, radians
 
+        # Keyword Args:
+            true_anomaly (float) : True anomaly, radians
+            mean_anomaly (float) : Mean anomaly, radians
+            eccentric_anomaly (float) : Eccentric anomaly, radians
+
+        # Notes:
+            * If "nu" is provided (6th argument), it will be used as the true anomaly
+            * Anomaly may also be set via keyword arguments; if so, the there should only be
+              5 input arguments
+            
         # Returns:
             satkit.kepler: Keplerian element set object
         """
@@ -1084,6 +1107,42 @@ class kepler:
             tuple[npt.ArrayLike[np.float64], npt.ArrayLike[np.float64]]: Tuple with two elements representing the position and velocity vectors
         """
 
+    def propagate(self, dt: duration|float) -> kepler:
+        """Propagate Keplerian element set by input duration
+
+        Args:
+            dt (duration | float): Duration by which to propagate the Keplerian element set
+                                   If float, value is seconds
+
+        Returns:
+            satkit.kepler: Keplerian element set object after propagation
+        """
+
+    @property
+    def mean_motion(self) -> float:
+        """Mean motion, radians / second
+        """
+
+    @property
+    def true_anomaly(self) -> float:
+        """True anomaly, radians
+        """
+
+    @property
+    def eccentric_anomaly(self) -> float:
+        """Eccentric anomaly, radians
+        """
+
+    @property
+    def mean_anomaly(self) -> float:
+        """Mean anomaly, radians
+        """
+
+    @property
+    def period(self) -> float:
+        """Orbital period, seconds
+        """
+
     def from_pv(
         pos: npt.ArrayLike[np.float64], vel: npt.ArrayLike[np.float64]
     ) -> kepler:
@@ -1355,3 +1414,85 @@ class consts:
     def jgm3_j2() -> float:
         """ "J2" gravity due oblateness of Earth from JGM3 gravity model, unitless
         """
+class satstate:
+    """
+    A convenience class representing a satellite position and velocity, and
+    optionally 6x6 position/velocity covariance at a particular instant in time
+
+    This class can be used to propagate the position, velocity, and optional
+    covariance to different points in time.
+    """
+
+    def __init__(
+        self,
+        time: time,
+        pos: npt.ArrayLike[np.float64],
+        vel: npt.ArrayLike[np.float64],
+        cov: npt.ArrayLike[np.float64] | None = None,
+    ):
+        """Create a new satellite state
+
+        Args:
+            time (satkit.time): Time instant of this state
+            pos (npt.ArrayLike[np.float64]): Position in meters in GCRF frame
+            vel (npt.ArrayLike[np.float64]): Velocity in meters / second in GCRF frame
+            cov (npt.ArrayLike[np.float64]|None, optional): Covariance in GCRF frame. Defaults to None.  If input, should be a 6x6 numpy array
+        
+        Returns:
+            satstate: New satellite state object
+        """
+
+    @property
+    def pos_gcrf(self) -> npt.ArrayLike[np.float64]:
+        """state position in meters in GCRF frame
+        
+        Returns:
+            npt.ArrayLike[np.float64]: 3-element numpy array representing position in meters in GCRF frame
+        """
+
+    @property
+    def vel_gcrf(self) -> npt.ArrayLike[np.float64]:
+        """Return this state velocity in meters / second in GCRF
+
+        Returns:
+            npt.ArrayLike[np.float64]: 3-element numpy array representing velocity in meters / second in GCRF frame
+        """
+
+    @property
+    def qgcrf2lvlh(self) -> quaternion:
+        """ Quaternion that rotates from the GCRF to the LVLH frame for the current state
+
+        Returns:
+            satkit.quaternion: Quaternion that rotates from the GCRF to the LVLH frame for the current state
+        """
+
+
+    @property
+    def cov(self) -> npt.ArrayLike[np.float64] | None:
+        """6x6 state covariance matrix in GCRF frame
+        
+        Returns:
+            npt.ArrayLike[np.float64] | None: 6x6 numpy array representing state covariance in GCRF frame or None if not set
+        """
+
+
+    @property
+    def time(self) -> time:
+        """Return time of this satellite state
+        
+        Returns:
+            satkit.time: Time instant of this state
+        """
+
+    def propagate(self, time: time | duration, propsettings=None) -> satstate:
+        """Propagate this state to a new time, specified by the "time" input, updating the position, the velocity, and the covariance if set
+
+        Args:
+            time (satkit.time|satkit.duration): Time or duration from current time to which to propagate the state
+
+        Keyword Arguments:
+            propsettings: satkit.satprop.propsettings object describing settings to use in the propagation. If omitted, default is used 
+
+        Returns:
+            satstate: New satellite state object representing the state at the new time
+        """

{satkit-0.2.8 → satkit-0.3.0}/python/satkit/satprop.pyi

@@ -38,131 +38,65 @@ import numpy as np
 import satkit
 import datetime
 
-class PropStats(typing.TypedDict):
-    """PropStats is a dictionary containing statistics for the propagation.
-    """
-    
-    num_eval: int
-    """int: Number of function evaluations of the force model computed during propagation function call
-    """
+class propstats:
+    @property
+    def num_eval() -> int:
+        """Number of function evaluations"""
 
-    accepted_steps: int
-    """int: Accepted steps in the adaptive Runga-Kutta solver
-    """
-    
-    rejected_steps: int
-    """int: Rejected steps in the adaptive Runga-Kutta solver
-    """
+    @property
+    def num_accept() -> int:
+        """Number of accepted steps in adaptive RK integrator"""
 
-class PropResult(typing.TypedDict):
-    """
-    PropResult is a dictionary containing the results of a high-precision orbit propagation that is returned by the "propagate" function
-    """
+    @property
+    def num_reject() -> int:
+        """Number of rejected steps in adaptive RK integrator"""
 
-    time: npt.ArrayLike[satkit.time]
-    """npt.ArrayLike[satkit.time]: List of satkit.time objects at which time is computed
-    """
+class propresult:
+    """Results of a satellite propagation
     
-    pos: npt.ArrayLike[np.float64]
-    """npt.ArrayLike[float]: GCRF position in meters at output times.  Output is Nx3 numpy matrix, where N is the number of times
+    This class lets the user access results of the satellite propagation
     """
 
-    vel: npt.ArrayLike[np.float64]
-    """npt.ArrayLike[float]: GCRF velocity in meters per second at output times.  Output is Nx3 numpy matrix, where N is the number of times
-    """
-
-    Phi: typing.NotRequired[npt.ArrayLike[np.float64]]
-    """6x6 State transition matrix corresponding to each time. Output is Nx6x6 numpy matrix, where N is the lenght of the output "time" list. Not included if output_phi kwarg is set to false (the default)
-    """
-
-    stats: PropStats
-    """
-    (PropStats): Python dictionary with statistics for the propagation. This includes:
-
-            * num_eval: Number of function evaluations of the force model required to get solution with desired accuracy
-            * accepted_steps: Accepted steps in the adpative Runga-Kutta solver
-            * rejected_steps: Rejected steps in the adaptive Runga-Kutta solver
-    """
-
-class satstate:
-    """
-    A convenience class representing a satellite position and velocity, and
-    optionally 6x6 position/velocity covariance at a particular instant in time
-
-    This class can be used to propagate the position, velocity, and optional
-    covariance to different points in time.
-    """
-
-    def __init__(
-        self,
-        time: satkit.time,
-        pos: npt.ArrayLike[np.float64],
-        vel: npt.ArrayLike[np.float64],
-        cov: npt.ArrayLike[np.float64] | None = None,
-    ):
-        """Create a new satellite state
-
-        Args:
-            time (satkit.time): Time instant of this state
-            pos (npt.ArrayLike[np.float64]): Position in meters in GCRF frame
-            vel (npt.ArrayLike[np.float64]): Velocity in meters / second in GCRF frame
-            cov (npt.ArrayLike[np.float64]|None, optional): Covariance in GCRF frame. Defaults to None.  If input, should be a 6x6 numpy array
-        
-        Returns:
-            satstate: New satellite state object
-        """
-
     @property
-    def pos(self) -> npt.ArrayLike[np.float64]:
-        """state position in meters in GCRF frame
-        
-        Returns:
-            npt.ArrayLike[np.float64]: 3-element numpy array representing position in meters in GCRF frame
-        """
+    def pos() -> npt.ArrayLike[float]:
+        """GCRF position of satellite, meters"""
 
     @property
-    def vel(self) -> npt.ArrayLike[np.float64]:
-        """Return this state velocity in meters / second in GCRF
-
-        Returns:
-            npt.ArrayLike[np.float64]: 3-element numpy array representing velocity in meters / second in GCRF frame
-        """
+    def vel() -> npt.ArrayLike[float]:
+        """GCRF velocity of satellite, meters/second"""
 
     @property
-    def qgcrf2lvlh(self) -> satkit.quaternion:
-        """ Quaternion that rotates from the GCRF to the LVLH frame for the current state
-
-        Returns:
-            satkit.quaternion: Quaternion that rotates from the GCRF to the LVLH frame for the current state
-        """
-
+    def state() -> npt.ArrayLike[float]:
+        """6-element state (pos + vel) of satellite in meters & meters/second"""
 
     @property
-    def cov(self) -> npt.ArrayLike[np.float64] | None:
-        """6x6 state covariance matrix in GCRF frame
-        
-        Returns:
-            npt.ArrayLike[np.float64] | None: 6x6 numpy array representing state covariance in GCRF frame or None if not set
-        """
+    def time() -> satkit.time:
+        """Time at which state is valid"""
 
+    @property
+    def stats() -> propstats:
+        """Statistics of propagation"""
 
     @property
-    def time(self) -> satkit.time:
-        """Return time of this satellite state
-        
-        Returns:
-            satkit.time: Time instant of this state
-        """
+    def phi() -> npt.ArrayLike[np.float64]|None:
+        """6x6 State transition matrix 
+        or None if not computed
+        """        
 
-    def propagate(self, time: satkit.time, propsettings=None) -> satstate:
-        """Propagate this state to a new time, specified by the "time" input, updating the position, the velocity, and the covariance if set
+    def interp(time: satkit.time, output_phi: bool=False) -> npt.ArrayLike[np.float64]|typing.Tuple[npt.ArrayLike[np.float64], npt.ArrayLike[np.float64]]:
+        """Interpolate state at given time
+
+        Args:
+            time (satkit.time): Time at which to interpolate state
 
         Keyword Arguments:
-            propsettings: satkit.satprop.propsettings object describing settings to use in the propagation. If omitted, default is used 
+            output_phi (bool): Output 6x6 state transition matrix at the interpolated time
 
         Returns:
-            satstate: New satellite state object representing the state at the new time
+            6-element vector representing state at given time
+            if output_phi, also output 6x6 state transition matrix at given time
         """
+    
 
 class satproperties_static:
     """Satellite properties relevant for drag and radiation pressure
@@ -271,7 +205,7 @@ def propagate(
     vel: npt.ArrayLike[float],
     start: satkit.time,
     **kwargs,
-) -> PropResult:
+) -> propresult:
     """High-precision orbit propagator
 
     Notes:
@@ -299,21 +233,13 @@ def propagate(
         duration_secs (float): duration in seconds from "tm" for at which new position and velocity will be computed.
         duration_days (float): duration in days from "tm" at which new position and velocity will be computed.
         duration (satkit.duration): duration from "tm" at which new position & velocity will be computed.
-        dt_secs (float): Interval in seconds between "starttime" and "stoptime" at which solution will also be computed
-        dt_days (float): Interval in days between "starttime" and "stoptime" at which solution will also be computed
-        dt (satkit.duration): Interval over which new position & velocity will be computed
         output_phi (bool): Output 6x6 state transition matrix between "starttime" and "stoptime" (and at intervals, if specified)
         propsettings (propsettings): "propsettings" object with input settings for the propagation. if left out, default will be used.
-        satproperties (satproperties_static): "SatPropertiesStatic" object with drag and radiation pressure succeptibility of satellite. If left out, drag and radiation pressure are neglected
+        satproperties (satproperties_static): "SatPropertiesStatic" object with drag and radiation pressure succeptibility of satellite. 
+                                            If left out, drag and radiation pressure are neglected
+        output_dense: boolean indicting whether or not dense output should be recorded.  Default is false.  If true, this will allow for calling the "interp" function
+                      to query states at arbitrary times between the start time and the stop time
 
     Returns:
-        (PropResult): Python dictionary with the following elements:
-            * "time": list of satkit.time objects at which solution is computed
-            * "pos": GCRF position in meters at "time".  Output is a Nx3 numpy matrix, where N is the length of the output "time" list
-            * "vel": GCRF velocity in meters / second at "time".  Output is a Nx3 numpy matrix, where N is the length of the output "time" list
-            *  "Phi": 6x6 State transition matrix corresponding to each time. Output is Nx6x6 numpy matrix, where N is the lenght of the output "time" list. Not included if output_phi kwarg is set to false (the default)
-            * "stats": Python dictionary with statistics for the propagation. This includes:
-                * "num_eval": Number of function evaluations of the force model required to get solution with desired accuracy
-                * "accepted_steps": Accepted steps in the adpative Runga-Kutta solver
-                * "rejected_steps": Rejected steps in the adaptive Runga-Kutta solver
+        (propresult): Propagation result object holding state outputs, statistics, and dense output if requested
     """

{satkit-0.2.8 → satkit-0.3.0/python/satkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satkit
-Version: 0.2.8
+Version: 0.3.0
 Summary: Satellite Orbital Dynamics Toolkit
 Author-email: Steven Michael <ssmichael@gmail.com>
 Maintainer-email: Steven Michael <ssmichael@gmail.com>

{satkit-0.2.8 → satkit-0.3.0}/python/satkit.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ python/satkit/density.pyi
 python/satkit/frametransform.pyi
 python/satkit/jplephem.pyi
 python/satkit/moon.pyi
+python/satkit/planets.pyi
 python/satkit/py.typed
 python/satkit/satkit.pyi
 python/satkit/satprop.pyi
@@ -31,6 +32,7 @@ src/consts.rs
 src/duration.rs
 src/earth_orientation_params.rs
 src/earthgravity.rs
+src/frames.rs
 src/itrfcoord.rs
 src/jplephem.rs
 src/kepler.rs
@@ -77,15 +79,18 @@ src/pybindings/pyastrotime.rs
 src/pybindings/pyconsts.rs
 src/pybindings/pydensity.rs
 src/pybindings/pyduration.rs
+src/pybindings/pyframes.rs
 src/pybindings/pyframetransform.rs
 src/pybindings/pygravity.rs
 src/pybindings/pyitrfcoord.rs
 src/pybindings/pyjplephem.rs
 src/pybindings/pykepler.rs
 src/pybindings/pylpephem_moon.rs
+src/pybindings/pylpephem_planets.rs
 src/pybindings/pylpephem_sun.rs
 src/pybindings/pynrlmsise.rs
 src/pybindings/pypropagate.rs
+src/pybindings/pypropresult.rs
 src/pybindings/pypropsettings.rs
 src/pybindings/pyquaternion.rs
 src/pybindings/pysatproperties.rs