tessl/pypi-spiceypy

A Python wrapper for the NAIF CSPICE Toolkit providing essential tools for spacecraft navigation and planetary science calculations

Overview

Eval results

Files

E-Kernels (Event Kernels)

Name: tessl/pypi-spiceypy
Author: tessl

Database-like functionality for storing, querying, and manipulating structured data in SPICE. E-kernels provide relational database capabilities within the SPICE system, allowing storage of mission events, instrument parameters, and other tabular data with full SQL-like query support.

Capabilities

Database Creation and Management

Create and manage E-kernel database files for storing structured mission data.

def ekopn(fname: str, ifname: str) -> int:
    """
    Open new E-kernel file for writing.
    
    Parameters:
    - fname: str, E-kernel file name
    - ifname: str, internal file name
    
    Returns:
    int: file handle
    """

def ekcls(handle: int) -> None:
    """
    Close E-kernel file.
    
    Parameters:
    - handle: int, file handle
    
    Returns:
    None
    """

Table and Segment Operations

Define table structures and manage data segments within E-kernels.

def ekbseg(handle: int, tabnam: str, cnames: List[str], decls: List[str]) -> None:
    """
    Begin new E-kernel segment.
    
    Parameters:
    - handle: int, file handle
    - tabnam: str, table name
    - cnames: List[str], column names
    - decls: List[str], column declarations
    
    Returns:
    None
    """

def ekappr(handle: int, segno: int) -> None:
    """
    Append records to E-kernel segment.
    
    Parameters:
    - handle: int, file handle
    - segno: int, segment number
    
    Returns:
    None
    """

Data Insertion

Insert various data types into E-kernel tables.

def ekacec(handle: int, segno: int, recno: int, column: str, nvals: int, cdata: List[str], isnull: bool) -> None:
    """
    Add character data to E-kernel column.
    
    Parameters:
    - handle: int, file handle
    - segno: int, segment number
    - recno: int, record number
    - column: str, column name
    - nvals: int, number of values
    - cdata: List[str], character data array
    - isnull: bool, null flag
    
    Returns:
    None
    """

def ekaced(handle: int, segno: int, recno: int, column: str, nvals: int, ddata: ndarray, isnull: bool) -> None:
    """
    Add double precision data to E-kernel column.
    
    Parameters:
    - handle: int, file handle
    - segno: int, segment number  
    - recno: int, record number
    - column: str, column name
    - nvals: int, number of values
    - ddata: ndarray, double precision data array
    - isnull: bool, null flag
    
    Returns:
    None
    """

def ekacei(handle: int, segno: int, recno: int, column: str, nvals: int, idata: List[int], isnull: bool) -> None:
    """
    Add integer data to E-kernel column.
    
    Parameters:
    - handle: int, file handle
    - segno: int, segment number
    - recno: int, record number  
    - column: str, column name
    - nvals: int, number of values
    - idata: List[int], integer data array
    - isnull: bool, null flag
    
    Returns:
    None
    """

Query Operations

Perform SQL-like queries on E-kernel data.

def ekfind(query: str, lenout: int) -> Tuple[int, bool, str]:
    """
    Find E-kernel data satisfying query.
    
    Parameters:
    - query: str, SQL-like query string
    - lenout: int, maximum length of error message
    
    Returns:
    Tuple[int, bool, str]: (nmrows, error, errmsg)
    """

def eknelt(selidx: int, row: int) -> int:
    """
    Return number of elements in specified column entry.
    
    Parameters:
    - selidx: int, column selection index
    - row: int, row number
    
    Returns:
    int: number of elements
    """

Data Retrieval

Extract data from E-kernel query results.

def ekgc(selidx: int, row: int, lenout: int) -> Tuple[str, bool]:
    """
    Get character data from E-kernel query results.
    
    Parameters:
    - selidx: int, column selection index
    - row: int, row number
    - lenout: int, maximum string length
    
    Returns:
    Tuple[str, bool]: (cdata, null_flag)
    """

def ekgd(selidx: int, row: int) -> Tuple[float, bool]:
    """
    Get double precision data from E-kernel query results.
    
    Parameters:
    - selidx: int, column selection index
    - row: int, row number
    
    Returns:
    Tuple[float, bool]: (ddata, null_flag)
    """

def ekgi(selidx: int, row: int) -> Tuple[int, bool]:
    """
    Get integer data from E-kernel query results.
    
    Parameters:
    - selidx: int, column selection index
    - row: int, row number
    
    Returns:
    Tuple[int, bool]: (idata, null_flag)
    """

Record Management

Insert, update, and delete records in E-kernel tables.

def ekinsr(handle: int, segno: int, recno: int) -> None:
    """
    Insert new record into E-kernel segment.
    
    Parameters:
    - handle: int, file handle
    - segno: int, segment number
    - recno: int, record number
    
    Returns:
    None
    """

def ekdelr(handle: int, segno: int, recno: int) -> None:
    """
    Delete record from E-kernel segment.
    
    Parameters:
    - handle: int, file handle
    - segno: int, segment number
    - recno: int, record number
    
    Returns:
    None
    """

Schema Information

Query E-kernel table structure and metadata.

def ekccnt(table: str) -> int:
    """
    Return count of columns in E-kernel table.
    
    Parameters:
    - table: str, table name
    
    Returns:
    int: number of columns
    """

def ekcii(table: str, cindex: int, lenout: int) -> Tuple[str, SpiceEKAttDsc]:
    """
    Get column information from E-kernel table.
    
    Parameters:
    - table: str, table name
    - cindex: int, column index
    - lenout: int, maximum column name length
    
    Returns:
    Tuple[str, SpiceEKAttDsc]: (column_name, attribute_descriptor)
    """

File Loading and Management

Load and unload E-kernel files for querying.

def eklef(fname: str) -> int:
    """
    Load E-kernel file for read access.
    
    Parameters:
    - fname: str, E-kernel file name
    
    Returns:
    int: file handle
    """

def ekuef(handle: int) -> None:
    """
    Unload E-kernel file.
    
    Parameters:
    - handle: int, file handle
    
    Returns:
    None
    """

Common Usage Patterns

Creating and Populating E-Kernel

import spiceypy as spice
import numpy as np

# Create new E-kernel file
handle = spice.ekopn("mission_events.ek", "Mission Events Database")

# Define table structure
table_name = "EVENTS"
column_names = ["TIME", "EVENT_TYPE", "DESCRIPTION", "DURATION"]
column_decls = [
    "TIME DOUBLE PRECISION",
    "EVENT_TYPE CHARACTER*(20)",  
    "DESCRIPTION CHARACTER*(100)",
    "DURATION DOUBLE PRECISION"
]

# Begin new segment
spice.ekbseg(handle, table_name, column_names, column_decls)

# Insert event records
for i, event in enumerate(events):
    # Insert new record
    spice.ekinsr(handle, 0, i)
    
    # Add data to columns
    spice.ekaced(handle, 0, i, "TIME", 1, np.array([event.time]), False)
    spice.ekacec(handle, 0, i, "EVENT_TYPE", 1, [event.type], False)
    spice.ekacec(handle, 0, i, "DESCRIPTION", 1, [event.description], False)
    spice.ekaced(handle, 0, i, "DURATION", 1, np.array([event.duration]), False)

# Close file
spice.ekcls(handle)

Querying E-Kernel Data

# Load E-kernel for querying
handle = spice.eklef("mission_events.ek")

# Perform SQL-like query
query = "SELECT TIME, EVENT_TYPE FROM EVENTS WHERE DURATION > 3600.0"
nmrows, error, errmsg = spice.ekfind(query, 1000)

if not error:
    print(f"Found {nmrows} matching records")
    
    # Extract results
    for row in range(nmrows):
        # Get time (column 0)
        time_val, null_flag = spice.ekgd(0, row)
        
        # Get event type (column 1)  
        event_type, null_flag = spice.ekgc(1, row, 50)
        
        print(f"Row {row}: Time={time_val}, Type={event_type}")
else:
    print(f"Query error: {errmsg}")

# Unload file
spice.ekuef(handle)

Schema Inspection

# Load E-kernel
handle = spice.eklef("mission_events.ek")

# Get table column information
table_name = "EVENTS"
num_columns = spice.ekccnt(table_name)

print(f"Table '{table_name}' has {num_columns} columns:")

for i in range(num_columns):
    col_name, attr_desc = spice.ekcii(table_name, i, 50)
    print(f"  Column {i}: {col_name}")

spice.ekuef(handle)

Install with Tessl CLI