spac-kit 0.1.0.dev0__py3-none-any.whl

spac_kit/parser/Packets.py

@@ -0,0 +1,46 @@
+"""CCSDSpy packet specialized for configurable APID parsing."""
+from typing import Callable
+
+import ccsdspy
+
+
+class SimpleAPIDPacket(ccsdspy.VariableLength):
+    """Simple Packet definition, with name and associated APID."""
+
+    def __init__(self, fields: list[ccsdspy.PacketField], name: str, apid: int):
+        """Constructor."""
+        super().__init__(fields)
+        self.apid = apid
+        self.name = name
+
+
+class PreParserAPIDPacket(SimpleAPIDPacket):
+    """Packet definition used to pre-parse packets.
+
+    This is used when the structure vary for a single APID
+    depending on one field in this packet.
+    """
+
+    def __init__(
+        self,
+        fields: list[ccsdspy.PacketField],
+        name: str,
+        apid: int,
+        decision_field: str = None,
+        decision_fun: Callable = lambda x: x,
+    ):
+        """Constructor."""
+        super().__init__(fields, apid, name)
+        self.decision_field = decision_field
+        self.decision_fun = decision_fun
+
+
+class ParserSubAPIDPacket(SimpleAPIDPacket):
+    """Packet definition associated to a specific flavor of structure within a single APID."""
+
+    def __init__(
+        self, fields: list[ccsdspy.PacketField], name: str, apid: int, sub_apid: int
+    ):
+        """Constructor."""
+        super().__init__(fields, apid, name)
+        self.sub_apid = sub_apid

spac_kit/parser/__init__.py

@@ -0,0 +1,10 @@
+"""Generic code to parse a downlink binary file encoded using CCSDS."""
+import os
+from logging.config import fileConfig
+
+conf_file_dir = os.path.dirname(os.path.abspath(__file__))
+fileConfig(os.path.join(conf_file_dir, "logger.conf"))
+
+from .parse_ccsds_downlink import parse_ccsds_file  # noqa
+from .remove_non_ccsds_headers import strip_non_ccsds_headers  # noqa
+from .test_utils import compare  # noqa

spac_kit/parser/downlink_to_excel.py

@@ -0,0 +1,97 @@
+"""Utility to convert a downlink CCSDS binary file to excel."""
+import argparse
+import logging
+import os.path
+
+import pandas as pd
+from spac_kit.parser.parse_ccsds_downlink import parse_ccsds_file
+from spac_kit.parser.remove_non_ccsds_headers import strip_non_ccsds_headers
+
+logger = logging.getLogger(__name__)
+
+
+def get_parser():
+    """Parser for the command line utility."""
+    parser = argparse.ArgumentParser(description="Parse Files")
+    parser.add_argument("--file", type=str, required=True, help="Input File")
+    parser.add_argument(
+        "--bdsem",
+        action="store_true",
+        help="Mode BDSEM, with specific, non-CCSDS, packet wrappers, "
+        "if not present, RAW mode is assumed, "
+        "with other specific non CCSDS markers in betwwen packets",
+    )
+
+    parser.add_argument(
+        "--pkt-header",
+        action="store_true",
+        help="When additional non CCSDS header are added between packets",
+    )
+
+    parser.add_argument(
+        "--json-header",
+        action="store_true",
+        help="When a JSON ASCII header starts the file",
+    )
+
+    parser.add_argument(
+        "--calculate-crc",
+        action="store_true",
+        help="Check if CRC in packet matches with the one calculateed, "
+        "return the calculated CRC in the spreadsheet next to the one of the packet.",
+    )
+
+    return parser
+
+
+def add_tab_to_xlsx(dfs, writer, name=""):
+    """Add tab to excel writer from a dictionary, recursively.
+
+    Only use the name in the leaf of the dictionary tree.
+
+    @param dfs: dictionary (of dictionary) of pandas dataframes or single pandas dataframe
+    @param writer: pandas.ExcelWriter
+    @param name: name of the tab to be used, optional when
+    @return: Nothing
+    """
+    if isinstance(dfs, dict):
+        for name, df in dfs.items():
+            add_tab_to_xlsx(df, writer, name=name)
+    else:
+        logger.info("Adding tab %s to excel spreadsheet", name)
+        dfs.to_excel(writer, sheet_name=name, index=True)
+
+
+def export_dfs_to_xlsx(dfs, filename1):
+    """Export a dictionnary of pandas dataframes to an Excel file."""
+    with pd.ExcelWriter(filename1) as writer:
+        add_tab_to_xlsx(dfs, writer)
+
+
+def export_ccsds_to_excel(ccsds_file, output_filename, do_calculate_crc):
+    """Export a binary file of CCSDS packets into an Excel file."""
+    dfs = parse_ccsds_file(ccsds_file, do_calculate_crc)
+    export_dfs_to_xlsx(dfs, output_filename)
+
+
+def main():
+    """Command line interface to parse downlink binary file and export to Excel file."""
+    parser = get_parser()
+    args = parser.parse_args()
+
+    with open(args.file, "rb") as f:
+        ccsds_file = strip_non_ccsds_headers(
+            f, args.bdsem, args.pkt_header, args.json_header
+        )
+
+        # to write the content of the file without non CCSDS code
+        # with open("ecm_test.bin", "wb") as f:
+        #    f.write(ccsds_file.read())
+
+        file_base, _ = os.path.splitext(args.file)
+        xlsx_filename = file_base + ".xlsx"
+        export_ccsds_to_excel(ccsds_file, xlsx_filename, args.calculate_crc)
+
+
+if __name__ == "__main__":
+    main()

spac_kit/parser/logger.conf

@@ -0,0 +1,27 @@
+[loggers]
+keys=root,sampleLogger
+
+[handlers]
+keys=consoleHandler
+
+[formatters]
+keys=sampleFormatter
+
+[logger_root]
+level=DEBUG
+handlers=consoleHandler
+
+[logger_sampleLogger]
+level=DEBUG
+handlers=consoleHandler
+qualname=sampleLogger
+propagate=0
+
+[handler_consoleHandler]
+class=StreamHandler
+level=DEBUG
+formatter=sampleFormatter
+args=(sys.stdout,)
+
+[formatter_sampleFormatter]
+format=%(asctime)s - %(name)s - %(levelname)s - %(message)s

spac_kit/parser/parse_ccsds_downlink.py

@@ -0,0 +1,375 @@
+"""CCSDS parser for binary file with multiple APIDs."""
+from __future__ import annotations
+
+import gc
+import io
+import logging
+
+import ccsdspy
+import crccheck
+import numpy as np
+import pandas as pd
+from spac_kit.parser.util import default_pkt
+
+logger = logging.getLogger(__name__)
+
+
+class CCSDSParsingException(Exception):
+    """CCSDS packet parsing Exception."""
+
+    pass
+
+
+class CRCNotCalculatedError(Exception):
+    """CRC Calculation exception."""
+
+    pass
+
+
+class CalculatedChecksum(ccsdspy.converters.Converter):
+    """Converter which calculates a CRC checksum from a parsed packet and compare it with the one found in the packet.
+
+    TODO: make something better, by supporting any packets as input...
+    """
+
+    CRC = crccheck.crc.Crc16CcittFalse
+    JUMBO_CRC = crccheck.crc.Crc32Mpeg2
+    JUMBO_TLM_PKT_LEN_BYTES = 4089  # not including the CCSDS header
+
+    def __init__(self):
+        """Initialization."""
+        pass
+
+    @classmethod
+    def calculate_crc(
+        cls,
+        ccsds_version_number,
+        ccsds_packet_type,
+        ccsds_secondary_flag,
+        ccsds_apid,
+        ccsds_sequence_flag,
+        ccsds_sequence_count,
+        ccsds_packet_length,
+        body,
+    ):
+        """Calculate one CRC from the parsed fields of one packet.
+
+        Parsed fields must be the CCSDS header and one body excluding the CRC at the end of the packet.
+        """
+        pkt_header_bit_string = ""
+        # TODO re-use header field length in ccsdspy packet_types.py
+        pkt_header_bit_string += "{0:03b}".format(ccsds_version_number)
+        pkt_header_bit_string += "{0:01b}".format(ccsds_packet_type)
+        pkt_header_bit_string += "{0:01b}".format(ccsds_secondary_flag)
+        pkt_header_bit_string += "{0:011b}".format(ccsds_apid)
+        pkt_header_bit_string += "{0:02b}".format(ccsds_sequence_flag)
+        pkt_header_bit_string += "{0:014b}".format(ccsds_sequence_count)
+        pkt_header_bit_string += "{0:016b}".format(ccsds_packet_length)
+        pkt_bytearray = [
+            int(pkt_header_bit_string[i : i + 8], 2)
+            for i in range(0, len(pkt_header_bit_string), 8)
+        ]
+        pkt_bytearray += body.tolist()
+
+        crc = (
+            cls.JUMBO_CRC
+            if ccsds_packet_length > cls.JUMBO_TLM_PKT_LEN_BYTES
+            else cls.CRC
+        )
+        return crc.calc(pkt_bytearray)
+
+    def convert(
+        self,
+        ccsds_version_number_array,
+        ccsds_packet_type_array,
+        ccsds_secondary_flag_array,
+        ccsds_apid_array,
+        ccsds_sequence_flag_array,
+        ccsds_sequence_count_array,
+        ccsds_packet_length_array,
+        body_array,
+    ):
+        """Converter to add a calculated CRC to the parsed packets.
+
+        @param ccsds_version_number_array: from the CCSDS header
+        @param ccsds_packet_type_array: from the CCSDS header
+        @param ccsds_secondary_flag_array: from the CCSDS header
+        @param ccsds_apid_array: from the CCSDS header
+        @param ccsds_sequence_flag_array: from the CCSDS header
+        @param ccsds_sequence_count_array: from the CCSDS header
+        @param ccsds_packet_length_array: from the CCSDS header
+        @param body_array: body of the packet, without the trailing CRC.
+        @return: the array of calculated CRCs.
+        """
+        calculated_crc_array = []
+
+        for (
+            ccsds_version_number,
+            ccsds_packet_type,
+            ccsds_secondary_flag,
+            ccsds_apid,
+            ccsds_sequence_flag,
+            ccsds_sequence_count,
+            ccsds_packet_length,
+            body,
+        ) in zip(
+            ccsds_version_number_array,
+            ccsds_packet_type_array,
+            ccsds_secondary_flag_array,
+            ccsds_apid_array,
+            ccsds_sequence_flag_array,
+            ccsds_sequence_count_array,
+            ccsds_packet_length_array,
+            body_array,
+        ):
+            crc = self.calculate_crc(
+                ccsds_version_number,
+                ccsds_packet_type,
+                ccsds_secondary_flag,
+                ccsds_apid,
+                ccsds_sequence_flag,
+                ccsds_sequence_count,
+                ccsds_packet_length,
+                body,
+            )
+            calculated_crc_array.append(crc)
+
+        return calculated_crc_array
+
+
+def calculate_crc(f, crc_size_bytes=2):
+    """Calculate a CRC for each packet so to compare it with the CRC sent at the end of the packets."""
+    pkt = ccsdspy.VariableLength(
+        [
+            ccsdspy.PacketArray(
+                name="body",
+                data_type="uint",
+                bit_length=8,
+                array_shape="expand",  # makes the body field expand
+            ),
+            ccsdspy.PacketField(
+                name="checksum_real", data_type="uint", bit_length=8 * crc_size_bytes
+            ),
+        ]
+    )
+
+    input_fields = [
+        "CCSDS_VERSION_NUMBER",
+        "CCSDS_PACKET_TYPE",
+        "CCSDS_SECONDARY_FLAG",
+        "CCSDS_APID",
+        "CCSDS_SEQUENCE_FLAG",
+        "CCSDS_SEQUENCE_COUNT",
+        "CCSDS_PACKET_LENGTH",
+        "body",
+    ]
+    pkt.add_converted_field(
+        input_fields,
+        "checksum_calculated",
+        CalculatedChecksum(),
+    )
+
+    try:
+        parsed_result = pkt.load(f, include_primary_header=True, reset_file_obj=True)
+
+        # check that the calculated checksum and the one found in the packet are the same
+        if np.all(
+            parsed_result["checksum_real"] == parsed_result["checksum_calculated"]
+        ):
+            # return the found checksum for further comparisons
+            return parsed_result["checksum_real"]
+        else:
+            raise CCSDSParsingException(
+                "The CRC calculated does not match the CRC read in the packet "
+            )
+    except IndexError:
+        logger.warning("Unable to parse packet to calculate CRC")
+        raise CRCNotCalculatedError("Unable to parse packet to calculate CRC")
+
+
+def import_ccsds_packet_packages():
+    """Import of the subpackages of ccsds.packets which are meant to contain the CCSDSpy packet definitions.
+
+    Stolen from https://packaging.python.org/en/latest/guides/creating-and-discovering-plugins/#using-namespace-packages
+
+    @return: the set of the imported packages
+    """
+    import importlib
+    import pkgutil
+
+    # TODO: use a constant for ccsds.packets
+    import ccsds.packets  # noqa
+
+    def iter_namespace(ns_pkg):
+        return pkgutil.iter_modules(ns_pkg.__path__, ns_pkg.__name__ + ".")
+
+    return {
+        name: importlib.import_module(name)
+        for finder, name, ispkg in iter_namespace(ccsds.packets)
+    }
+
+
+def get_packet_definitions():
+    """Select packet definitions which will be parsed in the first round or second round, as a refinement for some APIDs.
+
+    First round parsing: object instances of _BasePackets which have an `apid` but no `sub_apid`
+    Second round parsing: object instances of _BasePackets which have an `apid` and a `sub_apid`
+    """
+    # TODO use the clasees defined in Packets.py to simply the handling of packets
+    first_round_parsers = {}
+    second_round_parsers = {}
+
+    import_ccsds_packet_packages()
+
+    for object in gc.get_objects():
+        if isinstance(object, ccsdspy.packet_types._BasePacket) and hasattr(
+            object, "apid"
+        ):
+            if hasattr(object, "sub_apid"):
+                if object.apid not in second_round_parsers:
+                    second_round_parsers[object.apid] = {}
+                if "pkts" not in second_round_parsers[object.apid]:
+                    second_round_parsers[object.apid]["pkts"] = {}
+                second_round_parsers[object.apid]["pkts"][object.sub_apid] = object
+            else:
+                first_round_parsers[object.apid] = object
+                if hasattr(object, "decision_fun"):
+                    if object.apid not in second_round_parsers:
+                        second_round_parsers[object.apid] = {}
+                    second_round_parsers[object.apid]["pre_parser"] = object
+
+    return first_round_parsers, second_round_parsers
+
+
+def get_sub_packet_keys(parsed_apids, sub_apid: dict):
+    """Identify sub-packet keys when single APId does not have consistent packet structures."""
+    decision_fun = sub_apid["pre_parser"].decision_fun
+    if hasattr(sub_apid["pre_parser"], "decision_field"):
+        decision_field = sub_apid["pre_parser"].decision_field
+        return [
+            decision_fun(decision_value)
+            for decision_value in list(parsed_apids[decision_field])
+        ]
+    else:
+        # all the elements of the parsed_aids dictionary have
+        # the same length which is the number of packet parsed.
+        # we pick the first one to iterate on our packets.
+        first_key = list(parsed_apids.keys())[0]
+        return [decision_fun() for _ in range(0, len(parsed_apids[first_key]))]
+
+
+def distribute_packets(keyss, stream1):
+    """Distribute binary stream into multiple binary stream with consistent sub-packet structures.
+
+    Used when single APID does not have consistent packet structure.
+    """
+    buffers = {}
+    rows = ccsdspy.utils.split_packet_bytes(stream1)
+    for i in range(0, len(keyss)):
+        if keyss[i] not in buffers:
+            buffers[keyss[i]] = bytes()
+        buffers[keyss[i]] += rows[i]
+    buffers = {k: io.BytesIO(v) for k, v in buffers.items()}
+    return buffers
+
+
+def parse_ccsds_file(ccsds_file: str, do_calculate_crc: bool = False):
+    """Parse a pure CCSDS binary file (only CCSDS packets)."""
+    apid_packets, apid_multi_pkt = get_packet_definitions()
+    logger.info("Split input file per APIDs")
+    stream_by_apid = ccsdspy.utils.split_by_apid(ccsds_file)
+    dfs = dict()
+    for apid, streams in stream_by_apid.items():
+        logger.info("Parse APID %s", apid)
+        try:
+            pkt = apid_packets.get(apid, default_pkt)
+            parsed_apids = pkt.load(
+                streams, include_primary_header=True, reset_file_obj=True
+            )
+            if do_calculate_crc:
+                try:
+                    parsed_apids["calculated_crc"] = calculate_crc(streams)
+                except CRCNotCalculatedError as e:
+                    logger.warning(str(e))
+            name = get_tab_name(apid, pkt, dfs.keys())
+            if apid in apid_multi_pkt:
+                dfs[name] = dict()
+                keys = get_sub_packet_keys(parsed_apids, apid_multi_pkt[apid])
+                buffer = distribute_packets(keys, streams)
+                for key, minor_pkt in apid_multi_pkt[apid]["pkts"].items():
+                    logger.info(
+                        "Parse sub-APID %s %s",
+                        apid_multi_pkt[apid]["pre_parser"].decision_fun,
+                        key,
+                    )
+                    if hasattr(minor_pkt, "set_alt_inputs"):
+                        minor_pkt.set_alt_inputs(
+                            dfs[name]
+                        )  # add reference to previously parsed pkt in the same group
+                    parsed_sub_apid = minor_pkt.load(
+                        buffer[key], include_primary_header=True, reset_file_obj=True
+                    )
+                    inner_name = get_tab_name(apid, minor_pkt, dfs.keys())
+                    parsed_sub_apid = cast_to_list(parsed_sub_apid)
+                    if do_calculate_crc:
+                        try:
+                            parsed_sub_apid["calculated_crc"] = calculate_crc(streams)
+                        except CRCNotCalculatedError as e:
+                            logger.warning(str(e))
+                    dfs[name][inner_name] = pd.DataFrame.from_dict(parsed_sub_apid)
+                    logger.info(
+                        "%s/%s, found %i records.",
+                        name,
+                        inner_name,
+                        dfs[name][inner_name].size,
+                    )
+            else:
+                try:
+                    parsed_apids = cast_to_list(parsed_apids)
+                    current_df = pd.DataFrame.from_dict(parsed_apids)
+                    dfs[name] = current_df
+                    logger.info("%s, found %i records.", name, len(current_df))
+                except ValueError as e:
+                    print(str(e))
+        except AssertionError:
+            logger.warning(
+                "APID %i was not parseable because packet length inconsistent with CCSDS header description",
+                apid,
+            )
+        except CCSDSParsingException as e:
+            logger.warning("APID %i: %s", apid, str(e))
+
+    return dfs
+
+
+def get_tab_name(apid, pkt_def, existing_names):
+    """Proposes a tab name for each APID or sub-packet structure of an APID.
+
+    The tab name can be used as keys in the dictionary of DataFrames or as tab names in the Excel spreadsheet.
+
+    @param apid: APID
+    @param pkt_def: current packet definition.
+     preferably, the packet definition has a "name" property which will be used to name the tab.
+     If not available the name of the class implementing the packet structure definitionn is used.
+    @param existing_names: already used names, to avoid duplicates. A counter is added to duplicate names.
+    @return: a unique tab name for the current APID and packet structure definition.
+    """
+    if hasattr(pkt_def, "name"):
+        name = f"{apid}.{pkt_def.name}"
+    else:
+        name = f"{apid}.{pkt_def.__class__.__name__}"
+    # we need that in case the name is used twice so that data is not overridden
+    n = 1
+    while name in existing_names:
+        name = f"{name} ({n})"
+    return name
+
+
+def cast_to_list(d):
+    """Casts any multidimensional arrays to lists."""
+    for key, value in d.items():
+        if hasattr(value[0].__class__, "tolist"):
+            value = [v.tolist() for v in value]
+            d[key] = value
+
+    return d

spac_kit/parser/remove_non_ccsds_headers.py

@@ -0,0 +1,144 @@
+"""Remove non CCSDS binary code from input streams."""
+import io
+import logging
+
+import bitstring
+from tqdm import tqdm
+
+logger = logging.getLogger(__name__)
+
+BYTE_SIZE_IN_BITS = 8
+CCSDS_HEADER_LENGTH_BYTES = 8
+
+
+def remove_bdsem_and_message_headers(f):
+    """Removes extra headers provided by the BDSEM data generation.
+
+    @param f: file handler
+    @return: file handler
+    """
+    buffer = io.BytesIO()
+
+    bit_stream = bitstring.ConstBitStream(f)
+
+    n_pkts = 0
+    logger.info("Remove BDSEM wrappers and message headers.")
+    pbar = tqdm(total=bit_stream.length)
+    while bit_stream.pos < bit_stream.length:
+        pbar.update(bit_stream.pos)
+        control_word = bit_stream.read("uintle:32")
+        sse_length = control_word
+
+        # skipping 32 bits of unused
+        _ = bit_stream.read(32)
+        packet_length = sse_length - 4  # remove the unused bytes
+
+        n_pkts += 1
+        logger.debug("read packet %i", n_pkts)
+        packet_data = bit_stream.read(packet_length * 8)
+        packet_data_bytes = packet_data.tobytes()
+        # read CCSDS header to double check the length of the packet
+        ccsds_packet_length = int.from_bytes(
+            packet_data_bytes[4:6], byteorder="big", signed=False
+        )
+        if ccsds_packet_length - 1 == packet_length - CCSDS_HEADER_LENGTH_BYTES:
+            buffer.write(packet_data_bytes)
+        else:
+            apid = (
+                int.from_bytes(packet_data_bytes[0:2], byteorder="big", signed=False)
+                & 0b0000011111111111
+            )
+            sequence_cnt = (
+                int.from_bytes(packet_data_bytes[2:3], byteorder="big", signed=False)
+                & 0b0011111111111111
+            )
+            logger.warning(
+                "Skip packet apid %i, sequence count %i: length did not match with the packet length specified in the message header",
+                apid,
+                sequence_cnt,
+            )
+
+    buffer.seek(0)
+    return buffer
+
+
+def remove_bdsem(f):
+    """Remove BDSEM headers."""
+    buffer = io.BytesIO()
+
+    bit_stream = bitstring.ConstBitStream(f)
+    logger.info("Remove BDSEM wrappers.")
+    pbar = tqdm(total=bit_stream.length)
+    while bit_stream.pos < bit_stream.length:
+        pbar.update(bit_stream.pos)
+        packet_header = bit_stream.read(48)
+        packet_length = packet_header[-16:].uint
+        packet_data = bit_stream.read(packet_length * 8)
+        crc = bit_stream.read(8)
+        buffer.write(packet_header.tobytes() + packet_data.tobytes() + crc.tobytes())
+
+    buffer.seek(0)
+
+    return buffer
+
+
+def remove_mise_and_headers(f):
+    """Remove packet markers from Raw mode file."""
+    header_size = 4
+    ccsds_header_size = 6
+    offset_size = 1
+    buffer = io.BytesIO()
+
+    raw_data = f.read()
+    starting_idx = []
+
+    logger.info("Remove packet markers.")
+    logger.info("Get starting indices.")
+    for i in tqdm(range(0, len(raw_data[:-header_size]))):
+        if start_sequence(raw_data[i : i + header_size]):
+            starting_idx.append(i)
+
+    logger.info("Rebuild the binary stream skipping the markers")
+    for s in tqdm(starting_idx):
+        hdr_start = s + header_size
+        hdr_end = hdr_start + ccsds_header_size
+        ccsds_header = raw_data[hdr_start:hdr_end]
+        pkt_len = int.from_bytes(ccsds_header[-2:], byteorder="big") + offset_size
+        data = raw_data[hdr_start : hdr_end + pkt_len]
+        buffer.write(data)
+
+    buffer.seek(0)
+
+    return buffer
+
+
+def start_sequence(seq):
+    """Returns True if seq is on the beginning of a marker between CCSDS packets."""
+    return seq[1] == 0xF0 and seq[0] == seq[2] == seq[3] != 0x00
+
+
+def strip_non_ccsds_headers(
+    file_handler, is_bdsem: bool, has_pkt_header: bool, has_json_header: bool
+):
+    """Remove all cases of non CCSDS headers which can occur in Europa-Clipper SDS inputs, mostly in test cases.
+
+    @param filename: input binary filename
+    @param is_bdsem: file coming from BDSEM, else RAW
+    @param has_pkt_header:
+    @param has_json_header:
+    @return: the file handler where the CCSDS packets start
+    """
+    if has_json_header:
+        logger.info("Skip json header.")
+        file_handler.readline()
+
+    if is_bdsem:
+        if has_pkt_header:
+            return remove_bdsem_and_message_headers(file_handler)
+        else:
+            return remove_bdsem(file_handler)
+    else:
+        if has_pkt_header:
+            return remove_mise_and_headers(file_handler)
+        else:
+            return file_handler

spac_kit/parser/test_utils.py

@@ -0,0 +1,67 @@
+"""Utilities to test the packet parsing."""
+import logging
+import os
+import pickle
+
+import pandas as pd
+from spac_kit.parser import parse_ccsds_file
+from spac_kit.parser import strip_non_ccsds_headers
+
+logger = logging.getLogger(__name__)
+
+
+def compare(
+    local_dir: str,
+    is_bdsem: bool,
+    has_pkt_header: bool,
+    has_json_header: bool,
+    create_output: bool = False,
+):
+    """Run paring and compare results with a reference.
+
+    @param local_dir:
+    @param is_bdsem:
+    @param has_pkt_header:
+    @param has_json_header:
+    @param create_output:
+    @return:
+    """
+    input_file = os.path.join(local_dir, "in.bin")
+
+    with open(input_file, "rb") as f:
+        ccsds_file = strip_non_ccsds_headers(
+            f, is_bdsem, has_pkt_header, has_json_header
+        )
+        dfs = parse_ccsds_file(ccsds_file, do_calculate_crc=True)
+
+    output_file = os.path.join(local_dir, "out.pickle")
+
+    # save the result as needed
+    if create_output:
+        with open(output_file, "wb") as f:
+            f.write(pickle.dumps(dfs))
+
+    with open(output_file, "rb") as f:
+        dfs_expected = pickle.load(f)
+
+    recursive_compare(dfs, dfs_expected)
+
+
+def recursive_compare(dfs, dfs_expected):
+    """Compare embedded dictionary of dictionaries of panda dataframes. Compare the keys and the actual dataframes.
+
+    None should be missing and all should match.
+    @param dfs: dictionnary of dictionbaries of dataframe
+    @param dfs_expected: expected dictionnary of dictionnaries
+    @return: True is the pandas dataframe are identical at the same location as in the
+    """
+    for k, df in dfs.items():
+        logger.info("Compare dataframe %s", k)
+        assert k in dfs_expected.keys()
+        if isinstance(dfs_expected[k], dict):
+            recursive_compare(df, dfs_expected[k])
+        else:
+            pd.testing.assert_frame_equal(df, dfs_expected[k], check_dtype=False)
+        del dfs_expected[k]
+
+    assert len(dfs_expected) == 0

spac_kit/parser/util.py

@@ -0,0 +1,14 @@
+"""Utilities shared."""
+import ccsdspy
+from ccsdspy.constants import BITS_PER_BYTE
+
+default_pkt = ccsdspy.VariableLength(
+    [
+        ccsdspy.PacketArray(
+            name="data",
+            data_type="uint",
+            bit_length=BITS_PER_BYTE,
+            array_shape="expand",
+        )
+    ]
+)

spac_kit-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,334 @@
+Metadata-Version: 2.4
+Name: spac_kit
+Version: 0.1.0.dev0
+Summary: Collection of Python tools for working with CCSDS Space Packets
+Home-page: https://github.com/CCSDSPy/SPaC-Kit
+Author: NASA/Caltech/JPL
+License: Apache License
+        ==============
+        
+        _Version 2.0, January 2004_
+        _&lt;<http://www.apache.org/licenses/>&gt;_
+        
+        ### Terms and Conditions for use, reproduction, and distribution
+        
+        #### 1. Definitions
+        
+        “License” shall mean the terms and conditions for use, reproduction, and
+        distribution as defined by Sections 1 through 9 of this document.
+        
+        “Licensor” shall mean the copyright owner or entity authorized by the copyright
+        owner that is granting the License.
+        
+        “Legal Entity” shall mean the union of the acting entity and all other entities
+        that control, are controlled by, or are under common control with that entity.
+        For the purposes of this definition, “control” means **(i)** the power, direct or
+        indirect, to cause the direction or management of such entity, whether by
+        contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the
+        outstanding shares, or **(iii)** beneficial ownership of such entity.
+        
+        “You” (or “Your”) shall mean an individual or Legal Entity exercising
+        permissions granted by this License.
+        
+        “Source” form shall mean the preferred form for making modifications, including
+        but not limited to software source code, documentation source, and configuration
+        files.
+        
+        “Object” form shall mean any form resulting from mechanical transformation or
+        translation of a Source form, including but not limited to compiled object code,
+        generated documentation, and conversions to other media types.
+        
+        “Work” shall mean the work of authorship, whether in Source or Object form, made
+        available under the License, as indicated by a copyright notice that is included
+        in or attached to the work (an example is provided in the Appendix below).
+        
+        “Derivative Works” shall mean any work, whether in Source or Object form, that
+        is based on (or derived from) the Work and for which the editorial revisions,
+        annotations, elaborations, or other modifications represent, as a whole, an
+        original work of authorship. For the purposes of this License, Derivative Works
+        shall not include works that remain separable from, or merely link (or bind by
+        name) to the interfaces of, the Work and Derivative Works thereof.
+        
+        “Contribution” shall mean any work of authorship, including the original version
+        of the Work and any modifications or additions to that Work or Derivative Works
+        thereof, that is intentionally submitted to Licensor for inclusion in the Work
+        by the copyright owner or by an individual or Legal Entity authorized to submit
+        on behalf of the copyright owner. For the purposes of this definition,
+        “submitted” means any form of electronic, verbal, or written communication sent
+        to the Licensor or its representatives, including but not limited to
+        communication on electronic mailing lists, source code control systems, and
+        issue tracking systems that are managed by, or on behalf of, the Licensor for
+        the purpose of discussing and improving the Work, but excluding communication
+        that is conspicuously marked or otherwise designated in writing by the copyright
+        owner as “Not a Contribution.”
+        
+        “Contributor” shall mean Licensor and any individual or Legal Entity on behalf
+        of whom a Contribution has been received by Licensor and subsequently
+        incorporated within the Work.
+        
+        #### 2. Grant of Copyright License
+        
+        Subject to the terms and conditions of this License, each Contributor hereby
+        grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+        irrevocable copyright license to reproduce, prepare Derivative Works of,
+        publicly display, publicly perform, sublicense, and distribute the Work and such
+        Derivative Works in Source or Object form.
+        
+        #### 3. Grant of Patent License
+        
+        Subject to the terms and conditions of this License, each Contributor hereby
+        grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+        irrevocable (except as stated in this section) patent license to make, have
+        made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+        such license applies only to those patent claims licensable by such Contributor
+        that are necessarily infringed by their Contribution(s) alone or by combination
+        of their Contribution(s) with the Work to which such Contribution(s) was
+        submitted. If You institute patent litigation against any entity (including a
+        cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+        Contribution incorporated within the Work constitutes direct or contributory
+        patent infringement, then any patent licenses granted to You under this License
+        for that Work shall terminate as of the date such litigation is filed.
+        
+        #### 4. Redistribution
+        
+        You may reproduce and distribute copies of the Work or Derivative Works thereof
+        in any medium, with or without modifications, and in Source or Object form,
+        provided that You meet the following conditions:
+        
+        * **(a)** You must give any other recipients of the Work or Derivative Works a copy of
+        this License; and
+        * **(b)** You must cause any modified files to carry prominent notices stating that You
+        changed the files; and
+        * **(c)** You must retain, in the Source form of any Derivative Works that You distribute,
+        all copyright, patent, trademark, and attribution notices from the Source form
+        of the Work, excluding those notices that do not pertain to any part of the
+        Derivative Works; and
+        * **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any
+        Derivative Works that You distribute must include a readable copy of the
+        attribution notices contained within such NOTICE file, excluding those notices
+        that do not pertain to any part of the Derivative Works, in at least one of the
+        following places: within a NOTICE text file distributed as part of the
+        Derivative Works; within the Source form or documentation, if provided along
+        with the Derivative Works; or, within a display generated by the Derivative
+        Works, if and wherever such third-party notices normally appear. The contents of
+        the NOTICE file are for informational purposes only and do not modify the
+        License. You may add Your own attribution notices within Derivative Works that
+        You distribute, alongside or as an addendum to the NOTICE text from the Work,
+        provided that such additional attribution notices cannot be construed as
+        modifying the License.
+        
+        You may add Your own copyright statement to Your modifications and may provide
+        additional or different license terms and conditions for use, reproduction, or
+        distribution of Your modifications, or for any such Derivative Works as a whole,
+        provided Your use, reproduction, and distribution of the Work otherwise complies
+        with the conditions stated in this License.
+        
+        #### 5. Submission of Contributions
+        
+        Unless You explicitly state otherwise, any Contribution intentionally submitted
+        for inclusion in the Work by You to the Licensor shall be under the terms and
+        conditions of this License, without any additional terms or conditions.
+        Notwithstanding the above, nothing herein shall supersede or modify the terms of
+        any separate license agreement you may have executed with Licensor regarding
+        such Contributions.
+        
+        #### 6. Trademarks
+        
+        This License does not grant permission to use the trade names, trademarks,
+        service marks, or product names of the Licensor, except as required for
+        reasonable and customary use in describing the origin of the Work and
+        reproducing the content of the NOTICE file.
+        
+        #### 7. Disclaimer of Warranty
+        
+        Unless required by applicable law or agreed to in writing, Licensor provides the
+        Work (and each Contributor provides its Contributions) on an “AS IS” BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+        including, without limitation, any warranties or conditions of TITLE,
+        NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+        solely responsible for determining the appropriateness of using or
+        redistributing the Work and assume any risks associated with Your exercise of
+        permissions under this License.
+        
+        #### 8. Limitation of Liability
+        
+        In no event and under no legal theory, whether in tort (including negligence),
+        contract, or otherwise, unless required by applicable law (such as deliberate
+        and grossly negligent acts) or agreed to in writing, shall any Contributor be
+        liable to You for damages, including any direct, indirect, special, incidental,
+        or consequential damages of any character arising as a result of this License or
+        out of the use or inability to use the Work (including but not limited to
+        damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+        any and all other commercial damages or losses), even if such Contributor has
+        been advised of the possibility of such damages.
+        
+        #### 9. Accepting Warranty or Additional Liability
+        
+        While redistributing the Work or Derivative Works thereof, You may choose to
+        offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+        other liability obligations and/or rights consistent with this License. However,
+        in accepting such obligations, You may act only on Your own behalf and on Your
+        sole responsibility, not on behalf of any other Contributor, and only if You
+        agree to indemnify, defend, and hold each Contributor harmless for any liability
+        incurred by, or claims asserted against, such Contributor by reason of your
+        accepting any such warranty or additional liability.
+        
+        _END OF TERMS AND CONDITIONS_
+        
+        ### APPENDIX: How to apply the Apache License to your work
+        
+        To apply the Apache License to your work, attach the following boilerplate
+        notice, with the fields enclosed by brackets `[]` replaced with your own
+        identifying information. (Don't include the brackets!) The text should be
+        enclosed in the appropriate comment syntax for the file format. We also
+        recommend that a file or class name and description of purpose be included on
+        the same “printed page” as the copyright notice for easier identification within
+        third-party archives.
+        
+            Copyright [yyyy] [name of copyright owner]
+        
+            Licensed under the Apache License, Version 2.0 (the "License");
+            you may not use this file except in compliance with the License.
+            You may obtain a copy of the License at
+        
+              http://www.apache.org/licenses/LICENSE-2.0
+        
+            Unless required by applicable law or agreed to in writing, software
+            distributed under the License is distributed on an "AS IS" BASIS,
+            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+            See the License for the specific language governing permissions and
+            limitations under the License.
+        
+Project-URL: Homepage, https://github.com/CCSDSPy/SPaC-Kit
+Keywords: CCSDS,Space Packets,Downlink,Parser,Documentation
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: <3.10,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: ccsdspy~=1.3.0
+Requires-Dist: crccheck~=1.3.0
+Dynamic: license-file
+
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
+
+# SPaC-Kit
+
+## ✨ Introduction
+
+**SpaC-Kit** is a collection of Python tools for working with **CCSDS Space Packet**. It can generically:
+
+- Parse data files into **Pandas DataFrames** or **Excel spreadsheets**  
+- **(Scheduled Feb 2026)** – Generate documentation in multiple formats (**HTML**, **Markdown**, **reStructuredText**, **PDF**)  
+- **(Scheduled Apr 2026)** – Generate simulated packets  
+
+SpaC-Kit supports mission- or instrument-specific CCSDS packet structures via plugin packages built on the [**CCSDSPy** library](https://docs.ccsdspy.org/).
+
+### 🔌 Available Plugins
+
+- [Europa Clipper CCSDS packet definitions](https://github.com/joshgarde/europa-cliper-ccsds-plugin)  
+- Want to define your own CCSDS packets? [Open a ticket](https://github.com/CCSDSPy/SPaC-Kit/issues) to start the discussion.
+
+## Users
+
+### Requirement
+
+Tested with `python 3.9`.
+
+Optionnally, but recommended, create a virtual environment:
+
+    python3 -m venv my_virtual_env
+    sournce my_virtual_env/bin/activate
+
+
+### Install
+
+Install you plugin library first, for example Europa-Clipper CCSDS packets definitions:
+
+    git clone https://github.com/joshgarde/europa-cliper-ccsds-plugin.git
+    cd europa-cliper-ccsds-plugin   
+    pip install .
+
+Install the SPaC-Kit package:
+
+    pip install spac_kit
+
+### Use
+
+    parse-downlink --file {your ccsds file}
+
+See more options with:
+
+    parse-downlink --help
+
+
+## Developers
+
+### Requirements
+
+#### Python 3.9
+
+#### Create a virtual environment
+
+For example in command line:
+
+    python3 -m venv venv
+    source venv/bin/activate
+
+#### Install CCSDSPy
+
+To install the latest version of CCSDSPy:
+
+    pip install git+https://github.com/CCSDSPy/ccsdspy.git
+
+
+#### Deploy the project, for developers
+
+Clone the repository
+
+Install the package
+
+    pip install -e '.[dev]'
+    pre-commit install && pre-commit install -t pre-push
+
+Run an example:
+
+    python src/spa_kit/parse/downlink_to_excel.py
+
+or
+
+    spac-parse --help
+
+or
+
+    spac-parse --file ./data/ecm_mag_testcase6_cmds_split_out.log --bdsem --header
+
+
+#### Build and publish the package
+
+Update the version number in file `setup.cfg`
+
+Create a tag in the repository
+
+Build the project:
+
+    python3 -m pip install --upgrade build
+    rm -rf dist/
+    python3 -m build
+
+
+Publish the project:
+
+    twine upload dist/*
+
+
+
+## Acknowledgment
+
+This package heavily relies on `ccsdspy` library (see https://github.com/CCSDSPy/ccsdspy).

spac_kit-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,16 @@
+spac_kit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spac_kit/parser/Packets.py,sha256=2Gd7UB5Fy_0EQwHALsp3IBaTrTkIqIu-I0T6RbVot2Q,1346
+spac_kit/parser/__init__.py,sha256=Gs8mG_m3uu1eqepPfbfKYfhLVjXT3GijNWZWPwNywOM,405
+spac_kit/parser/downlink_to_excel.py,sha256=_LDNvTqtFWIe9k3u1NXDqiq3RnAg2IAFn9MyMzJzkys,3116
+spac_kit/parser/logger.conf,sha256=5SsIQtMVp4oDQS5Wm7fQLsHM2ris158RSUn-8JJoTFg,436
+spac_kit/parser/parse_ccsds_downlink.py,sha256=dWvKDapP9sMy6hWjxAVmddpQDfy7zlrtiC-KLym7wuM,13850
+spac_kit/parser/remove_non_ccsds_headers.py,sha256=YGHGUx8noMbvHGXEysomRNJW39e8qHV4tzmEhbSZaKY,4506
+spac_kit/parser/test_utils.py,sha256=TmtsrAPbIZjOcCFd14giSR5vr5F9unsftfv4S8DurNw,1967
+spac_kit/parser/util.py,sha256=g78PVA2I1aYEneLJaKGbr6PqylrdtefYIkagZZ8vBpM,302
+spac_kit-0.1.0.dev0.dist-info/licenses/LICENSE.md,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+spac_kit-0.1.0.dev0.dist-info/METADATA,sha256=VXoG02YQIBZuNYl4aD4RSBxCO-wFW1GaIbwNKwZcngw,15471
+spac_kit-0.1.0.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+spac_kit-0.1.0.dev0.dist-info/namespace_packages.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+spac_kit-0.1.0.dev0.dist-info/top_level.txt,sha256=2stGqiUpUjZ9xtRmkyA6ry8MGbHJIJrEeXH_kTutr7s,9
+spac_kit-0.1.0.dev0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+spac_kit-0.1.0.dev0.dist-info/RECORD,,

spac_kit-0.1.0.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

spac_kit-0.1.0.dev0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,194 @@
+Apache License
+==============
+
+_Version 2.0, January 2004_
+_&lt;<http://www.apache.org/licenses/>&gt;_
+
+### Terms and Conditions for use, reproduction, and distribution
+
+#### 1. Definitions
+
+“License” shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+“Licensor” shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+“Legal Entity” shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, “control” means **(i)** the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the
+outstanding shares, or **(iii)** beneficial ownership of such entity.
+
+“You” (or “Your”) shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+“Source” form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+“Object” form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+“Work” shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+“Derivative Works” shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+“Contribution” shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+“submitted” means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as “Not a Contribution.”
+
+“Contributor” shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+#### 2. Grant of Copyright License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+#### 3. Grant of Patent License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+#### 4. Redistribution
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+* **(a)** You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+* **(b)** You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+* **(c)** You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+#### 5. Submission of Contributions
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+#### 6. Trademarks
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+#### 7. Disclaimer of Warranty
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an “AS IS” BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+#### 8. Limitation of Liability
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+#### 9. Accepting Warranty or Additional Liability
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+_END OF TERMS AND CONDITIONS_
+
+### APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets `[]` replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same “printed page” as the copyright notice for easier identification within
+third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.

spac_kit-0.1.0.dev0.dist-info/namespace_packages.txt

@@ -0,0 +1 @@
+

spac_kit-0.1.0.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+spac_kit

spac_kit-0.1.0.dev0.dist-info/zip-safe

@@ -0,0 +1 @@
+