lasp-curryer 0.2.0__tar.gz

lasp_curryer-0.2.0/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.2.0/NOTICE

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

lasp_curryer-0.2.0/PKG-INFO

@@ -0,0 +1,243 @@
+Metadata-Version: 2.4
+Name: lasp-curryer
+Version: 0.2.0
+Summary: LASP SPICE extentions and geospatial data product generation tools.
+License: MIT
+License-File: LICENSE
+License-File: NOTICE
+Keywords: spice,geolocation,geometry,ephemeris,attitude,kernel,coordinates,lasp,university of colorado,naif
+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: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Provides-Extra: dev
+Provides-Extra: docs
+Provides-Extra: test
+Requires-Dist: affine (>=2.3)
+Requires-Dist: boto3
+Requires-Dist: furo ; extra == "docs"
+Requires-Dist: h5py (>=3.0,<3.14.0)
+Requires-Dist: ipython ; extra == "dev"
+Requires-Dist: jinja2 (>=3)
+Requires-Dist: myst-parser (>=0.18) ; extra == "docs"
+Requires-Dist: netcdf4 (>=1.6,<1.7.3)
+Requires-Dist: numpy (>=1.23,<2.0)
+Requires-Dist: openpyxl (>=3)
+Requires-Dist: pandas (>=1.5)
+Requires-Dist: pre-commit ; extra == "dev"
+Requires-Dist: pyproj (>=3.6)
+Requires-Dist: pytest ; extra == "test"
+Requires-Dist: pytest-cov ; extra == "test"
+Requires-Dist: pytest-randomly ; extra == "test"
+Requires-Dist: requests (>=2.28)
+Requires-Dist: responses (>=0.25.8) ; extra == "test"
+Requires-Dist: ruff ; extra == "dev"
+Requires-Dist: scipy (>=1.9)
+Requires-Dist: sphinx (>=5.0) ; extra == "docs"
+Requires-Dist: sphinx-autoapi (>=2.0) ; extra == "docs"
+Requires-Dist: spiceypy (>=6)
+Requires-Dist: tifffile (>=2024.1.1)
+Requires-Dist: xarray (>=2022.11)
+Project-URL: Documentation, https://lasp-curryer.readthedocs.io/
+Project-URL: Repository, https://github.com/lasp/curryer
+Description-Content-Type: text/markdown
+
+# Curryer
+
+A library for SPICE extensions and geospatial data product generation.
+
+- Github: https://github.com/lasp/curryer
+- PyPi: https://pypi.org/project/lasp-curryer/
+- Documentation: https://lasp-curryer.readthedocs.io/
+
+## Core Features
+
+- Extensions and wrappers for SPICE routines and common data patterns.
+- Automation of SPICE kernel creation from JSON definition files and modern data
+  file formats and third-party data structures.
+- Level-1 geospatial data processing routines (e.g., geolocation).
+
+## Install
+
+```shell
+pip install lasp-curryer
+```
+
+### Data / Binary Files
+
+_NOTE: Data files and precompiled binaries are not currently automated and thus
+require manual downloading. This will be addressed in the next major release._
+
+Download from the Curryer repo:
+
+- `data/generic` - Generic spice kernels (e.g., leapsecond kernel)
+  - Download
+- `data/<mission>` - Mission specific kernels and/or kernel definitions.
+
+Define the top-level directory using the environment variable `CURRYER_DATA_DIR`
+or pass the path to routines which require data files.
+
+Download Third-party Files:
+
+- SPICE Utilities: https://naif.jpl.nasa.gov/naif/utilities.html
+  - At minimum: `mkspk`, `msopck`, `brief`, `ckbreif`
+- SPICE Generic Kernels (large):
+  - [de430.bsp](https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/planets/de430.bsp),
+    place in `data/generic`.
+- PyProj Data:
+  - Data directory: `import pyproj; print(pyproj.datadir.get_user_data_dir())`
+  - [EGM96 TIFF](https://cdn.proj.org/us_nga_egm96_15.tif)
+- (OPTIONAL, USED FOR TESTING) `data/gmted` - Digital Elevation Model (DEMs) with global coverage at
+  15-arc-second.
+  - Alternatively, use the script [download_dem.py](bin/download_dem.py) to
+    download different types and/or resolutions from the USGS.
+
+## Examples
+
+### SPICE Extensions
+
+Time conversion:
+
+```python
+from curryer import spicetime
+
+print(spicetime.adapt(0, from_='ugps', to='iso'))
+# 1980-01-06 00:00:00.000000
+
+print(spicetime.adapt('2024-11-13', 'iso'))
+# 1415491218000000
+
+print(spicetime.adapt(1415491218000000, to='et'))
+# 784728069.1827033
+
+import numpy as np
+
+print(repr(spicetime.adapt(np.arange(4) * 60e6 + 1415491218000000, to='dt64')))
+# array(['2024-11-13T00:00:00.000000', '2024-11-13T00:01:00.000000',
+#        '2024-11-13T00:02:00.000000', '2024-11-13T00:03:00.000000'],
+#       dtype='datetime64[us]')
+```
+
+Abstractions:
+
+```python
+from curryer import spicierpy
+
+spicierpy.ext.infer_ids('ISS', 25544, from_norad=True)
+# {'mission': 'ISS',
+#  'spacecraft': -125544,
+#  'clock': -125544,
+#  'ephemeris': -125544,
+#  'attitude': -125544000,
+#  'instruments': {}}
+
+earth = spicierpy.obj.Body('Earth')
+print(earth, earth.id)
+# Body(EARTH) 399
+
+import curryer
+
+mkrn = curryer.meta.MetaKernel.from_json(
+    'data/tsis1/tsis_v01.kernels.tm.json', sds_dir='data/generic', relative=True
+)
+print(mkrn)
+# MetaKernel(Spacecraft(ISS_SC), Body(ISS_ELC3), Body(ISS_EXPA35), Body(TSIS_TADS),
+#   Body(TSIS_AZEL), Body(TSIS_TIM), Body(TSIS_TIM_GLINT))
+
+with spicierpy.ext.load_kernel([mkrn.sds_kernels, mkrn.mission_kernels]):
+    print(spicierpy.ext.instrument_boresight('TSIS_TIM'))
+# [0. 0. 1.]
+
+mkrn = curryer.meta.MetaKernel.from_json(
+    'tests/data/clarreo/cprs_v01.kernels.tm.json', sds_dir='data/generic', relative=True
+)
+print(mkrn)
+# MetaKernel(Spacecraft(ISS_SC), Body(CPRS_BASE), Body(CPRS_PEDE),
+#   Body(CPRS_AZ), Body(CPRS_YOKE), Body(CPRS_EL), Body(CPRS_HYSICS))
+
+with spicierpy.ext.load_kernel([mkrn.sds_kernels, mkrn.mission_kernels]):
+    print(curryer.compute.spatial.pixel_vectors('CPRS_HYSICS'))
+# (480,
+#  array([[ 0.00173869, -0.08715574,  0.99619318],
+#         [ 0.0017315 , -0.08679351,  0.99622482],
+#         [ 0.00172431, -0.08643127,  0.99625632],
+#         ...,
+#         [-0.00171712,  0.08606901,  0.9962877 ],
+#         [-0.00172431,  0.08643127,  0.99625632],
+#         [-0.0017315 ,  0.08679351,  0.99622482]]))
+```
+
+### SPICE Kernel Creation
+
+Create CLARREO Dynamic Kernels:
+
+```python
+import curryer
+
+meta_kernel = 'tests/data/clarreo/cprs_v01.kernels.tm.json'
+generic_dir = 'data/generic'
+kernel_configs = [
+    'data/clarreo/iss_sc_v01.ephemeris.spk.json',
+    'data/clarreo/iss_sc_v01.attitude.ck.json',
+    'data/clarreo/cprs_az_v01.attitude.ck.json',
+    'data/clarreo/cprs_el_v01.attitude.ck.json',
+]
+output_dir = '/tmp'
+input_file_or_obj = 'tests/data/demo/cprs_geolocation_tlm_20230101_20240430.nc'
+
+# Load meta kernel details. Includes existing static kernels.
+mkrn = curryer.meta.MetaKernel.from_json(meta_kernel, relative=True, sds_dir=generic_dir)
+
+# Create the dynamic kernels from the JSONs alone. Note that they
+# contain the reference to the input_data netcdf4 file to read.
+generated_kernels = []
+creator = curryer.kernels.create.KernelCreator(overwrite=False, append=False)
+
+# Generate the kernels from the config and input data (file or object).
+for kernel_config in kernel_configs:
+    generated_kernels.append(creator.write_from_json(
+        kernel_config, output_kernel=output_dir, input_data=input_file_or_obj,
+    ))
+
+```
+
+### Level-1 Geospatial Processing
+
+Geolocate CLARREO HYSICS Instrument:
+
+```python
+import pandas as pd
+import curryer
+
+meta_kernel = 'tests/data/clarreo/cprs_v01.kernels.tm.json'
+generic_dir = 'data/generic'
+
+time_range = ('2023-01-01', '2023-01-01T00:05:00')
+ugps_times = curryer.spicetime.adapt(pd.date_range(*time_range, freq='67ms', inclusive='left'), 'iso')
+
+# Load meta kernel details. Includes existing static kernels.
+mkrn = curryer.meta.MetaKernel.from_json(meta_kernel, relative=True, sds_dir=generic_dir)
+
+# Geolocate all the individual pixels and create the L1A data product!
+with curryer.spicierpy.ext.load_kernel([mkrn.sds_kernels, mkrn.mission_kernels]):
+    geoloc_inst = curryer.compute.spatial.Geolocate('CPRS_HYSICS')
+    l1a_dataset = geoloc_inst(ugps_times)
+    l1a_dataset.to_netcdf('cprs_geolocation_l1a_20230101.nc')
+
+```
+
+_Assumes dynamic kernels have been created and their file names defined within
+the metakernel JSON file._
+

lasp_curryer-0.2.0/README.md

@@ -0,0 +1,186 @@
+# Curryer
+
+A library for SPICE extensions and geospatial data product generation.
+
+- Github: https://github.com/lasp/curryer
+- PyPi: https://pypi.org/project/lasp-curryer/
+- Documentation: https://lasp-curryer.readthedocs.io/
+
+## Core Features
+
+- Extensions and wrappers for SPICE routines and common data patterns.
+- Automation of SPICE kernel creation from JSON definition files and modern data
+  file formats and third-party data structures.
+- Level-1 geospatial data processing routines (e.g., geolocation).
+
+## Install
+
+```shell
+pip install lasp-curryer
+```
+
+### Data / Binary Files
+
+_NOTE: Data files and precompiled binaries are not currently automated and thus
+require manual downloading. This will be addressed in the next major release._
+
+Download from the Curryer repo:
+
+- `data/generic` - Generic spice kernels (e.g., leapsecond kernel)
+  - Download
+- `data/<mission>` - Mission specific kernels and/or kernel definitions.
+
+Define the top-level directory using the environment variable `CURRYER_DATA_DIR`
+or pass the path to routines which require data files.
+
+Download Third-party Files:
+
+- SPICE Utilities: https://naif.jpl.nasa.gov/naif/utilities.html
+  - At minimum: `mkspk`, `msopck`, `brief`, `ckbreif`
+- SPICE Generic Kernels (large):
+  - [de430.bsp](https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/planets/de430.bsp),
+    place in `data/generic`.
+- PyProj Data:
+  - Data directory: `import pyproj; print(pyproj.datadir.get_user_data_dir())`
+  - [EGM96 TIFF](https://cdn.proj.org/us_nga_egm96_15.tif)
+- (OPTIONAL, USED FOR TESTING) `data/gmted` - Digital Elevation Model (DEMs) with global coverage at
+  15-arc-second.
+  - Alternatively, use the script [download_dem.py](bin/download_dem.py) to
+    download different types and/or resolutions from the USGS.
+
+## Examples
+
+### SPICE Extensions
+
+Time conversion:
+
+```python
+from curryer import spicetime
+
+print(spicetime.adapt(0, from_='ugps', to='iso'))
+# 1980-01-06 00:00:00.000000
+
+print(spicetime.adapt('2024-11-13', 'iso'))
+# 1415491218000000
+
+print(spicetime.adapt(1415491218000000, to='et'))
+# 784728069.1827033
+
+import numpy as np
+
+print(repr(spicetime.adapt(np.arange(4) * 60e6 + 1415491218000000, to='dt64')))
+# array(['2024-11-13T00:00:00.000000', '2024-11-13T00:01:00.000000',
+#        '2024-11-13T00:02:00.000000', '2024-11-13T00:03:00.000000'],
+#       dtype='datetime64[us]')
+```
+
+Abstractions:
+
+```python
+from curryer import spicierpy
+
+spicierpy.ext.infer_ids('ISS', 25544, from_norad=True)
+# {'mission': 'ISS',
+#  'spacecraft': -125544,
+#  'clock': -125544,
+#  'ephemeris': -125544,
+#  'attitude': -125544000,
+#  'instruments': {}}
+
+earth = spicierpy.obj.Body('Earth')
+print(earth, earth.id)
+# Body(EARTH) 399
+
+import curryer
+
+mkrn = curryer.meta.MetaKernel.from_json(
+    'data/tsis1/tsis_v01.kernels.tm.json', sds_dir='data/generic', relative=True
+)
+print(mkrn)
+# MetaKernel(Spacecraft(ISS_SC), Body(ISS_ELC3), Body(ISS_EXPA35), Body(TSIS_TADS),
+#   Body(TSIS_AZEL), Body(TSIS_TIM), Body(TSIS_TIM_GLINT))
+
+with spicierpy.ext.load_kernel([mkrn.sds_kernels, mkrn.mission_kernels]):
+    print(spicierpy.ext.instrument_boresight('TSIS_TIM'))
+# [0. 0. 1.]
+
+mkrn = curryer.meta.MetaKernel.from_json(
+    'tests/data/clarreo/cprs_v01.kernels.tm.json', sds_dir='data/generic', relative=True
+)
+print(mkrn)
+# MetaKernel(Spacecraft(ISS_SC), Body(CPRS_BASE), Body(CPRS_PEDE),
+#   Body(CPRS_AZ), Body(CPRS_YOKE), Body(CPRS_EL), Body(CPRS_HYSICS))
+
+with spicierpy.ext.load_kernel([mkrn.sds_kernels, mkrn.mission_kernels]):
+    print(curryer.compute.spatial.pixel_vectors('CPRS_HYSICS'))
+# (480,
+#  array([[ 0.00173869, -0.08715574,  0.99619318],
+#         [ 0.0017315 , -0.08679351,  0.99622482],
+#         [ 0.00172431, -0.08643127,  0.99625632],
+#         ...,
+#         [-0.00171712,  0.08606901,  0.9962877 ],
+#         [-0.00172431,  0.08643127,  0.99625632],
+#         [-0.0017315 ,  0.08679351,  0.99622482]]))
+```
+
+### SPICE Kernel Creation
+
+Create CLARREO Dynamic Kernels:
+
+```python
+import curryer
+
+meta_kernel = 'tests/data/clarreo/cprs_v01.kernels.tm.json'
+generic_dir = 'data/generic'
+kernel_configs = [
+    'data/clarreo/iss_sc_v01.ephemeris.spk.json',
+    'data/clarreo/iss_sc_v01.attitude.ck.json',
+    'data/clarreo/cprs_az_v01.attitude.ck.json',
+    'data/clarreo/cprs_el_v01.attitude.ck.json',
+]
+output_dir = '/tmp'
+input_file_or_obj = 'tests/data/demo/cprs_geolocation_tlm_20230101_20240430.nc'
+
+# Load meta kernel details. Includes existing static kernels.
+mkrn = curryer.meta.MetaKernel.from_json(meta_kernel, relative=True, sds_dir=generic_dir)
+
+# Create the dynamic kernels from the JSONs alone. Note that they
+# contain the reference to the input_data netcdf4 file to read.
+generated_kernels = []
+creator = curryer.kernels.create.KernelCreator(overwrite=False, append=False)
+
+# Generate the kernels from the config and input data (file or object).
+for kernel_config in kernel_configs:
+    generated_kernels.append(creator.write_from_json(
+        kernel_config, output_kernel=output_dir, input_data=input_file_or_obj,
+    ))
+
+```
+
+### Level-1 Geospatial Processing
+
+Geolocate CLARREO HYSICS Instrument:
+
+```python
+import pandas as pd
+import curryer
+
+meta_kernel = 'tests/data/clarreo/cprs_v01.kernels.tm.json'
+generic_dir = 'data/generic'
+
+time_range = ('2023-01-01', '2023-01-01T00:05:00')
+ugps_times = curryer.spicetime.adapt(pd.date_range(*time_range, freq='67ms', inclusive='left'), 'iso')
+
+# Load meta kernel details. Includes existing static kernels.
+mkrn = curryer.meta.MetaKernel.from_json(meta_kernel, relative=True, sds_dir=generic_dir)
+
+# Geolocate all the individual pixels and create the L1A data product!
+with curryer.spicierpy.ext.load_kernel([mkrn.sds_kernels, mkrn.mission_kernels]):
+    geoloc_inst = curryer.compute.spatial.Geolocate('CPRS_HYSICS')
+    l1a_dataset = geoloc_inst(ugps_times)
+    l1a_dataset.to_netcdf('cprs_geolocation_l1a_20230101.nc')
+
+```
+
+_Assumes dynamic kernels have been created and their file names defined within
+the metakernel JSON file._

lasp_curryer-0.2.0/curryer/__init__.py

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

lasp_curryer-0.2.0/curryer/compute/__init__.py

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

lasp_curryer-0.2.0/curryer/compute/abstract.py

@@ -0,0 +1,142 @@
+"""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:  # noqa E722
+            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])
+    )
+    if query.count() != 0:
+        raise ValueError("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()))
+
+    if query.count() != table.shape[0]:
+        raise ValueError("Database is missing some data.")
+    if auto_commit:
+        session.commit()
+    return table.shape[0]

lasp_curryer-0.2.0/curryer/compute/constants.py

@@ -0,0 +1,76 @@
+"""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