lasp-curryer 0.0.4__tar.gz

lasp_curryer-0.0.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 The Regents of the University of Colorado.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lasp_curryer-0.0.4/NOTICE

@@ -0,0 +1,2 @@
+Curryer
+Copyright (c) 2023 The Regents of the University of Colorado

lasp_curryer-0.0.4/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.1
+Name: lasp-curryer
+Version: 0.0.4
+Summary: LASP SPICE extentions and geospatial data product generation tools.
+License: MIT
+Keywords: LASP,SDP
+Author: Brandon Stone
+Author-email: brandon.h.stone@colorado.edu
+Requires-Python: >=3.9,<4
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Requires-Dist: jinja2 (>=3)
+Requires-Dist: netcdf4 (>=1.6)
+Requires-Dist: numpy (>=1.23,<2.0)
+Requires-Dist: openpyxl (>=3)
+Requires-Dist: pandas (>=1.5)
+Requires-Dist: pyhdf (>=0.11)
+Requires-Dist: pyproj (>=3.6)
+Requires-Dist: pyshp (>=2.3)
+Requires-Dist: requests (>=2.28)
+Requires-Dist: rioxarray (>=0.15)
+Requires-Dist: scipy (>=1.9)
+Requires-Dist: spiceypy (>=6)
+Requires-Dist: xarray (>=2022.11)
+Description-Content-Type: text/markdown
+
+# Curryer
+
+A library for SPICE extensions and geospatial data product generation.
+
+

lasp_curryer-0.0.4/README.md

@@ -0,0 +1,4 @@
+# Curryer
+
+A library for SPICE extensions and geospatial data product generation.
+

lasp_curryer-0.0.4/curryer/__init__.py

@@ -0,0 +1,12 @@
+"""Helper library for using high-level SPICE functions, creating SPICE kernels,
+and calculating spatial datasets.
+
+@author: Brandon Stone
+"""
+from . import compute
+from . import kernels
+from . import spicetime
+from . import spicierpy
+from . import meta
+from . import tle
+from . import utils

lasp_curryer-0.0.4/curryer/compute/__init__.py

@@ -0,0 +1,9 @@
+"""Methods for computing spatial and pointing datasets.
+
+@author: Brandon Stone
+"""
+from . import constants
+from . import elevation
+from . import ephemeris
+from . import pointing
+from . import spatial

lasp_curryer-0.0.4/curryer/compute/abstract.py

@@ -0,0 +1,147 @@
+"""Abstract mission data class.
+
+@author: Brandon Stone
+"""
+import functools
+import logging
+from abc import ABCMeta, abstractmethod
+from io import StringIO
+
+import numpy as np
+import pandas as pd
+
+
+logger = logging.getLogger(__name__)
+
+
+def log_return(max_rows=5):
+    """Log any output tables/arrays from a function.
+    """
+
+    def log_return_wrapper(func):
+        """Store the function to log output from.
+        """
+        _logger = logging.getLogger(getattr(func, '__module__', __name__))
+
+        @functools.wraps(func)
+        def log_return_call(*args, **kwargs):
+            """Call the wrapper function and log the output.
+            """
+            output = func(*args, **kwargs)
+
+            if _logger.isEnabledFor(logging.DEBUG):
+                output_name = output.__class__.__name__
+
+                # Table.
+                if isinstance(output, pd.DataFrame):
+                    if pd.get_option('display.width') == 80:
+                        pd.set_option('display.width', 140)
+                    info_strm = StringIO()
+                    _logger.debug('%s%s:\n %s', output_name, output.shape, output.to_string(max_rows=max_rows))
+                    output.info(buf=info_strm)
+                    _logger.debug('%s details:\n%s', output_name, info_strm.getvalue())
+
+                # Numpy array.
+                elif isinstance(output, np.ndarray):
+                    if np.get_printoptions()['threshold'] == 1000:
+                        np.set_printoptions(threshold=100)
+                    _logger.debug('%s%s:\n %s', output_name, output.shape, output)  # Auto trims.
+
+            return output
+
+        return log_return_call
+
+    return log_return_wrapper
+
+
+class AbstractMissionData(metaclass=ABCMeta):
+    """Abstract class to get/write mission data.
+    """
+
+    @abstractmethod
+    def __init__(self, microsecond_cadence, *args, **kwargs):
+        self.microsecond_cadence = microsecond_cadence
+        self._loaded_kernels = None
+        self.allow_nans = True
+
+    def __del__(self):
+        if not self._loaded_kernels:
+            return
+        try:
+            self._loaded_kernels.unload(clear=True)
+        except:
+            logging.exception('Error while unloading kernels:\n')
+
+    @log_return()
+    def get_times(self, ugps_range, cadence=None):
+        """Array of evenly spaced values.
+
+        Parameters
+        ----------
+        ugps_range : (int, int)
+            Time range [start, end).
+        cadence : int, optional
+            Number of microseconds to step by. Default=`self.DEFAULT_CADENCE`
+
+        Returns
+        -------
+        numpy.ndarray
+            Array of time values (int64).
+
+        """
+        if cadence is None:
+            cadence = self.microsecond_cadence
+        if len(ugps_range) != 2:
+            raise ValueError('Must specify two uGPS times: inclusive start, exclusive end.')
+
+        logger.debug('Determining times in range [%s] with cadence [%s]', ugps_range, cadence)
+        return np.arange(ugps_range[0], ugps_range[1], cadence)
+
+
+def write_to_database(table, session, dbtable, auto_commit):
+    """Insert table values using the SQLAlchemy bulk insert method.
+
+    Parameters
+    ----------
+    table : DataFrame
+    session : Session
+    dbtable : Table
+    auto_commit : bool
+
+    Returns
+    -------
+    int
+
+    """
+    logger.info('Inserting [%s] rows into [%s] @ [%s]', table.shape[0], dbtable.__table__.fullname, session)
+
+    if table.shape[0] == 0:
+        logger.warning('Skipping insert for empty dataset [%s]!', dbtable.__table__.fullname)
+        return 0
+
+    query = session.query(
+        dbtable,
+    ).filter(
+        dbtable.ugps >= int(table.index.min()),
+        dbtable.ugps <= int(table.index.max()),
+        *[getattr(dbtable, col) == table[col].iloc[0] for col in table.columns if col != 'ugps']
+        # dbtable.instrumentmodeid == int(table['instrumentmodeid'].iloc[0]),
+        # dbtable.version == int(table['version'].iloc[0])
+    )
+    assert query.count() == 0, 'Data already exists!'
+
+    # Bulk insert a list of dicts (rows).
+    #   Convert DataFrame to a Numpy records array to maintain
+    #   the individual column data types. Convert to a list to change
+    #   from Numpy scalar types to Python scalar types (e.g., int).
+    # TODO: Add an iter to flush every (e.g., 1440 rows / day's worth)?
+    col_names = (table.index.name, *table.columns)
+    session.bulk_insert_mappings(
+        dbtable,
+        (dict(zip(col_names, row)) for row in table.to_records().tolist())
+    )
+
+    assert query.count() == table.shape[0], 'Database is missing some data.'
+    if auto_commit:
+        session.commit()
+    return table.shape[0]

lasp_curryer-0.0.4/curryer/compute/constants.py

@@ -0,0 +1,75 @@
+"""SPICE related constants for TIM.
+
+@author: Brandon Stone
+"""
+from enum import IntFlag, unique
+from spiceypy.utils.exceptions import SpiceyError
+
+
+# Time-interval between output samples (TIM/SIM missions only).
+#   Units: Microseconds
+EPHEMERIS_TIMESTEP_USEC = 60000000
+ATTITUDE_TIMESTEP_USEC = 10000000
+
+# Astronomical unit (2012 definition)
+#   Units: KM / 1 AU
+#   Source: http://www.iau.org/static/resolutions/IAU2012_English.pdf
+#   Note: Java uses ###.66 instead of ###.700
+KM_PER_ASTRONOMICAL_UNIT = 149597870.700
+
+# Speed of light in a vacuum
+#   Units: KM / SEC
+SPEED_OF_LIGHT_KM_PER_S = 299792.458
+
+# WGS84 Ellipsoid reference
+#   Units: KM
+#   Source: https://epsg.org/ellipsoid_7030/WGS-84.html
+WGS84_SEMI_MAJOR_AXIS_KM = 6378.137
+WGS84_SEMI_MINOR_AXIS_KM = 6356.752314245
+WGS84_INVERSE_FLATTENING = 1 / 298.257223563
+WGS84_ECCENTRICITY2 = 2 * WGS84_INVERSE_FLATTENING - WGS84_INVERSE_FLATTENING ** 2
+
+
+@unique
+class SpatialQualityFlags(IntFlag):
+    GOOD = 0x0
+
+    SPICE_ERR_NO_RESULTS_FOUND = 0x1  # E.g. no surface intersect.
+    SPICE_ERR_MISSING_EPHEMERIS = 0x2
+    SPICE_ERR_MISSING_ATTITUDE = 0x4
+    SPICE_ERR_INVALID_LOCATION = 0x8  # E.g. inside planet.
+    SPICE_ERR_UNKNOWN_NONSPECIFIC = 0x10
+
+    CALC_UNEXPECTED_NOT_FINITE = 0x20
+
+    CALC_KERNELS_UNDESIRED_TLM = 0x40
+    CALC_KERNELS_FAILED = 0x80
+
+    CALC_ELLIPS_INSUFF_DATA = 0x100
+    CALC_ELLIPS_NO_INTERSECT = 0x200
+
+    # TODO: CALC_TERRAIN_INSUFF_DATA ?
+    CALC_TERRAIN_EXTREME_ZENITH = 0x400
+    CALC_TERRAIN_MAX_ITER = 0x800
+    CALC_TERRAIN_NOT_FINITE = 0x1000
+
+    CALC_ANCIL_INSUFF_DATA = 0x2000
+    CALC_ANCIL_NOT_FINITE = 0x4000
+
+    @classmethod
+    def from_spice_error(cls, error: SpiceyError):
+        if error is None:
+            return cls.GOOD
+        if not isinstance(error, SpiceyError):
+            raise TypeError(f'Method requires a SpiceyError, not: {type(error)}')
+        # if isinstance(error, NotFoundError):
+        #     return cls.SPICE_ERR_NO_LOOKUP_FOUND
+        if 'returns not found' in error.message:
+            return cls.SPICE_ERR_NO_RESULTS_FOUND
+        if 'SPICE(SPKINSUFFDATA)' in error.short:
+            return cls.SPICE_ERR_MISSING_EPHEMERIS
+        if 'SPICE(NOFRAMECONNECT)' in error.short:
+            return cls.SPICE_ERR_MISSING_ATTITUDE
+        if 'SPICE(NOTDISJOINT)' in error.short:
+            return cls.SPICE_ERR_INVALID_LOCATION
+        return cls.SPICE_ERR_UNKNOWN_NONSPECIFIC