dkist-header-validator 5.2.0__py3-none-any.whl

dkist_header_validator/tests/test_translator.py

@@ -0,0 +1,114 @@
+import pytest
+from astropy.io import fits
+
+from dkist_header_validator.translator import remove_spec_122_keys_and_spec_214_l0_keys
+from dkist_header_validator.translator import sanitize_to_spec214_level1
+from dkist_header_validator.translator import translate_spec122_to_spec214_l0
+
+
+def test_spec122_to_214_l0_valid(valid_translator_object):
+    """
+    Strips headers down to a 214 L1 object
+    Given: A valid SPEC-0122 object
+    When: Sanitizing headers
+    Then:
+    """
+    translate_spec122_to_spec214_l0(valid_translator_object)
+
+
+def test_spec122_to_214_l0_missing_required_keys(invalid_spec_122_object):
+    """
+    Translates an invalid SPEC-0122 object missing required
+    keys to a SPEC-214 l0 object
+    Given: A valid SPEC-0122 object
+    When: Translating headers
+    Then: Raises a KeyError exception
+    """
+    with pytest.raises(KeyError):
+        translate_spec122_to_spec214_l0(invalid_spec_122_object)
+
+
+@pytest.mark.parametrize("instrument", ["vbi"])
+def test_spec122_to_214_l0_missing_required_instrument_keys(
+    invalid_instrument_table_spec_122_object,
+):
+    """
+    Given: A SPEC-0122 object missing a required instrument key
+    When: Translating headers
+    Then: Raises a KeyError exception
+    """
+    invalid_obj, _ = invalid_instrument_table_spec_122_object
+    with pytest.raises(KeyError):
+        translate_spec122_to_spec214_l0(invalid_obj)
+
+
+def test_translate_to_214_l0_required_only_headers(valid_translator_object_required_only):
+    """
+    Translates a spec122 compliant header with only the keywords required by the DC
+    Given: A spec122 compliant header with only required keywords
+    When: Translating headers
+    Then: For a fits file input, return a HDUList and do not raise an exception
+          For a dict, HDUList, or header input, return a dictionary and do not raise an exception
+    """
+    translate_spec122_to_spec214_l0(valid_translator_object_required_only)
+
+
+def test_translate_to_214_l0_expected_only_headers(valid_translator_object_expected_only):
+    """
+    Translates a spec122 compliant header with only the keywords required by the DC
+    Given: A spec122 compliant header with only required keywords
+    When: Translating headers
+    Then: For a fits file input, return a HDUList and do not raise an exception
+          For a dict, HDUList, or header input, return a dictionary and do not raise an exception
+    """
+    translate_spec122_to_spec214_l0(valid_translator_object_expected_only)
+
+
+# I removed all of the compressed tests because a file (compressed or not) cannot go directly into the translator.
+# It has to go into the validator first, which will hand it to the translator in the right format
+
+
+def test_sanitize_s122(valid_translator_object):
+    """
+    Tries to sanitize a Spec-0122 object
+    Given: A valid SPEC-0122 object
+    When: Stripping down headers to 214 L1 (no 122 headers)
+    Then: Returns a header
+    """
+    sanitize_to_spec214_level1(valid_translator_object)
+
+
+def test_sanitize_translated_s214l0(valid_translator_object):
+    """
+    Tries to sanitize a Spec-214 L0 object
+    Given: A valid SPEC-0122 object
+    When: Translating and stripping down headers to 214 L1 (no 122 headers)
+    Then: Returns a header
+    """
+    s214_l0_header = translate_spec122_to_spec214_l0(valid_translator_object)
+    isinstance(sanitize_to_spec214_level1(s214_l0_header), fits.Header)
+
+
+def test_sanitize(valid_spec_214_no_file):
+    """
+    Sanitizes a SPEC-214 L1 object
+    Given: A valid SPEC-214 L1 object
+    When: Stripping down headers to 214 L1 (no 122 headers)
+    Then: For a header or a dict, return a fits header and do not raise an exception
+          For an HDUList or a file, return an HDUList and do not raise an exception
+    """
+    isinstance(sanitize_to_spec214_level1(valid_spec_214_no_file), fits.Header)
+
+
+def test_remove_spec_122_keys():
+    """
+    Given: A fits header containing 'level0_only' keys
+    When: Removing the 'level0_only' headers
+    Then: Those headers are no longer present
+    """
+    header = fits.header.Header()
+    header["VALID"] = "valid"
+    header["IPTASK"] = "should be removed"
+    processed_header = remove_spec_122_keys_and_spec_214_l0_keys(header)
+    assert "VALID" in processed_header.keys()
+    assert "IPTASK" not in processed_header.keys()

dkist_header_validator/translator.py

@@ -0,0 +1,251 @@
+import logging
+from datetime import datetime
+from functools import reduce
+from typing import Any
+from typing import IO
+
+from astropy.io import fits
+from astropy.io.fits.hdu.hdulist import HDUList
+from dkist_fits_specifications.spec122 import load_spec122
+from dkist_fits_specifications.spec214 import get_214_l0_only_keys
+from dkist_fits_specifications.spec214 import level0
+from dkist_fits_specifications.spec214 import load_processed_spec214
+from dkist_fits_specifications.spec214 import load_spec214
+
+logger = logging.getLogger(__name__)
+
+__all__ = [
+    "translate_spec122_to_spec214_l0",
+    "sanitize_to_spec214_level1",
+    "remove_extra_axis_keys",
+    "remove_spec_122_keys",
+]
+
+type_map = {"int": int, "float": float, "str": str, "bool": bool}
+
+
+def translate_spec122_to_spec214_l0(
+    spec122_input: HDUList | dict | fits.header.Header | str | IO | list,
+) -> dict | HDUList:
+    """
+    Convert spec 122 headers to spec 214 l0 headers
+
+    Parameters
+    ----------
+    spec122_input
+        Spec 122 headers or headers + data to convert
+    Returns
+    -------
+    spec214 l0 headers and (possibly) data
+    """
+    # extract headers and data
+    input_headers, input_data = _parse_fits_like_input(spec122_input)
+    # convert headers
+    output_headers = _add_214_l0_headers(input_headers)
+    # update DATE keyword
+    output_headers["DATE"] = datetime.now().isoformat()
+    if input_data is not None:  # return hdu list if the input had data
+        return _format_output_hdu(output_headers, input_data)
+    return output_headers  # return headers if only headers were given
+
+
+def sanitize_to_spec214_level1(
+    input_headers: HDUList | dict | fits.header.Header | str | IO | list,
+) -> dict | HDUList:
+    """
+    Remove all non-214 compliant header values
+
+    Parameters
+    ----------
+    input_headers
+        Spec 214 headers or headers + data to convert
+    Returns
+    -------
+        spec214 l1 headers and (possibly) data
+    """
+    # extract headers and data
+    input_headers, input_data = _parse_fits_like_input(input_headers)
+    header = fits.Header(input_headers)
+    # convert headers
+    expanded_214 = load_processed_spec214(**dict(input_headers))
+    all_214_keys = reduce(list.__add__, map(list, expanded_214.values()))
+
+    for keyword in tuple(header.keys()):
+        if keyword not in all_214_keys:
+            header.remove(keyword)
+
+    if input_data is not None:  # return hdu list if the input had data
+        return _format_output_hdu(header, input_data)
+    return header  # return headers if only headers were given
+
+
+def remove_spec_122_keys_and_spec_214_l0_keys(
+    input_headers: HDUList | dict | fits.header.Header | str | IO | list,
+) -> dict | HDUList:
+    """
+    Remove all spec 122 keys that are not in spec 214, along with all keys marked as spec 214 l0.
+
+    Parameters
+    ----------
+    input_headers
+        Spec 214 headers or headers + data to convert
+    Returns
+    -------
+        spec214 l1 headers and (possibly) data
+    """
+    # extract headers and data
+    input_headers, input_data = _parse_fits_like_input(input_headers)
+    header = input_headers
+    # Get "level0_only" keys and remove them from the header
+    for keyword in get_214_l0_only_keys():
+        header.remove(keyword=keyword, ignore_missing=True)
+    # Get header schemas
+    expanded_122 = load_spec122()
+    all_122_keys = reduce(list.__add__, map(list, expanded_122.values()))
+    expanded_214 = load_processed_spec214(**dict(input_headers))
+    all_214_keys = reduce(list.__add__, map(list, expanded_214.values()))
+
+    for keyword in header.keys():
+        # Only remove the keys that are in spec 122 AND not in spec 214
+        if (keyword in all_122_keys) and (keyword not in all_214_keys):
+            header.remove(keyword)
+
+    if input_data is not None:  # return hdu list if the input had data
+        return _format_output_hdu(header, input_data)
+    return header  # return headers if only headers were given
+
+
+def remove_extra_axis_keys(
+    input_headers: HDUList | dict | fits.header.Header | str | IO | list,
+) -> dict | HDUList:
+    """
+    Remove all keywords that refer to axes that don't exist in the data array
+
+    Parameters
+    ----------
+    input_headers
+        Spec 214 headers or headers + data
+    Returns
+    -------
+    Stripped headers and (possibly) data
+    """
+    # extract headers and data
+    input_headers, input_data = _parse_fits_like_input(input_headers)
+    header = fits.Header(input_headers)
+
+    # Get a list of all unexpanded keywords that have "n" in them
+    all_keys = reduce(list.__add__, map(list, load_spec214().values()))
+    n_keys = [i for i in all_keys if "n" in i]
+
+    # Remove all keywords where "n" is substituted by a larger number than NAXIS
+    for n_key in n_keys:
+        for i in range(header["NAXIS"] + 1, 6):
+            expanded_key = n_key.replace("n", str(i))
+            header.pop(expanded_key, None)
+
+    if input_data is not None:  # return hdu list if the input had data
+        return _format_output_hdu(header, input_data)
+    return header  # return headers if only headers were given
+
+
+def _parse_fits_like_input(
+    spec122_input: HDUList | dict | fits.header.Header | str | IO | list,
+) -> tuple[fits.Header, bytes | None]:
+    """
+    Parse out a header and optional data from the various types of input
+    """
+    if isinstance(spec122_input, dict):
+        return fits.Header(spec122_input), None
+    if isinstance(spec122_input, fits.header.Header):
+        return spec122_input, None
+    if isinstance(spec122_input, HDUList):
+        try:
+            return spec122_input[1].header, spec122_input[1].data
+        except IndexError:  # non-compressed
+            return spec122_input[0].header, spec122_input[0].data
+
+    # If headers are of any other type, see if it is a file and try to open that
+    try:  # compressed
+        with fits.open(spec122_input) as hdus:
+            return hdus[1].header, hdus[1].data
+    except IndexError:  # non-compressed
+        with fits.open(spec122_input) as hdus:
+            return hdus[0].header, hdus[0].data
+
+
+def _format_output_hdu(hdr, data) -> HDUList:
+    new_hdu = fits.PrimaryHDU(data)
+    hdu_list = fits.HDUList([new_hdu])
+    for key, value in hdr.items():
+        hdu_list[0].header[key] = value
+    return hdu_list
+
+
+def _add_214_l0_headers(header: dict[str, Any] | fits.Header):
+    """
+    Translates 122 keywords to 214 l0 keywords and returns a dictionary
+    """
+    result = {}  # output headers
+
+    # We need an extra layer of sanitation here because `load_level0_spec214` is a cached function
+    # and the weird header cards are not hashable
+    sanitized_header = {
+        k: v for k, v in header.items() if not isinstance(v, fits.header._HeaderCommentaryCards)
+    }
+
+    # Passing only INSTRUME=header["INSTRUME"] is a hack for speed. We know that right now the only schema processor
+    # that gets applied to 122 or 214 level0 schema (this happens in `load_level0_spec214`) is the instrument requiredness
+    # processor. Thus, we only need to pass a header consisting of `{INSTRUME: sanitized_header["INSTRUME"]}`.
+    # This results in a massive speed increase during translation because `load_level0_spec214` is cached. If we pass
+    # the whole header then each file will result in a new call to this function, but if we only pass the instrument
+    # then we only make new calls to `load_level0_spec214` at most 5 times (for each DKIST instrumet).
+    spec214_l0_schema_sections = level0.load_level0_spec214(
+        INSTRUME=sanitized_header.get("INSTRUME", "None")
+    ).values()
+    flat_spec214_l0_schema = {
+        key: schema
+        for definition in spec214_l0_schema_sections
+        for (key, schema) in definition.items()
+    }
+
+    # translate 122 -> 214 headers
+    for key, key_schema in flat_spec214_l0_schema.items():
+        result.update(_translate_key(key, key_schema, header))
+
+    # add remaining header values to result
+    hdr_keys_not_translated = {k: v for k, v in header.items() if k not in result}
+    result.update(hdr_keys_not_translated)
+    return result
+
+
+def _translate_key(key, key_schema, hdr) -> dict:
+    default_values = {"str": "default", "int": -999, "float": -999.9, "bool": False}
+    key_is_copied = key_schema.get("copy")
+    copy_schema_only = key_schema.get("copy") == "schema"
+    key_is_renamed = key_schema.get("rename")
+    renamed_key_is_in_header = key_is_renamed and (key_is_renamed in hdr)
+    key_is_required = key_schema.get("required")
+    key_is_in_header = key in hdr
+
+    if copy_schema_only and key_is_in_header:
+        return {key: default_values[key_schema["type"]]}
+    if key_is_copied and key_is_in_header:
+        return {key: hdr[key]}
+    if key_is_copied and not key_is_in_header and renamed_key_is_in_header:
+        return {key: hdr[key_schema.get("rename")]}
+    if (
+        key_is_copied
+        and not key_is_in_header
+        and key_is_renamed
+        and not renamed_key_is_in_header
+        and key_is_required
+    ):
+        raise KeyError(f" Required keyword {key!r} not found.")
+    if key_is_copied and not key_is_in_header and not key_is_renamed and key_is_required:
+        raise KeyError(f" Required keyword {key!r} not found.")
+    if not key_is_copied and key_is_required and key_is_in_header:
+        return {key: hdr[key]}
+    if not key_is_copied and key_is_required and not key_is_in_header:
+        return {key: default_values[key_schema["type"]]}
+    # nothing to translate
+    return {}

dkist_header_validator/utils/expansions.py

@@ -0,0 +1,18 @@
+from dkist_fits_specifications.utils import schema_type_hint
+from dkist_fits_specifications.utils.spec_processors.expansion import expand_schema
+from dkist_fits_specifications.utils.spec_processors.expansion import ExpansionIndex
+
+
+def expand_naxis(naxis: int, schema: schema_type_hint) -> schema_type_hint:
+    naxis_range = range(1, naxis + 1)
+    n_expansion = ExpansionIndex(index="n", size=1, values=naxis_range)
+    i_expansion = ExpansionIndex(index="i", size=1, values=naxis_range)
+    j_expansion = ExpansionIndex(index="j", size=1, values=naxis_range)
+    pp_expansion = ExpansionIndex(index="pp", size=2, values=[1, 10, 25, 75, 90, 95, 98, 99])
+    expansions = [n_expansion, i_expansion, j_expansion, pp_expansion]
+    return expand_schema(schema=schema, expansions=expansions)
+
+
+def expand_index_d(schema: schema_type_hint, *, DNAXIS: int, **kwargs) -> schema_type_hint:
+    d_expansion = ExpansionIndex(index="d", size=1, values=range(1, DNAXIS + 1))
+    return expand_schema(schema=schema, expansions=[d_expansion])

dkist_header_validator/version.py

@@ -0,0 +1,8 @@
+# Note that we need to fall back to the hard-coded version if either
+# setuptools_scm can't be imported or setuptools_scm can't determine the
+# version, so we catch the generic 'Exception'.
+try:
+    from setuptools_scm import get_version
+    __version__ = get_version(root='..', relative_to=__file__)
+except Exception:
+    __version__ = '5.2.0'

dkist_header_validator-5.2.0.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: dkist-header-validator
+Version: 5.2.0
+Summary: DKIST data validator
+Home-page: https://bitbucket.org/dkistdc/dkist-header-validator/src/main/
+Author: NSO / AURA
+Author-email: "aderks@nso.edu"
+License: MIT
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.10
+Requires-Dist: astropy>=5.0
+Requires-Dist: voluptuous<1.0.0,>=0.11.7
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: dkist-fits-specifications>=4.1.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
+Requires-Dist: deepdiff; extra == "test"
+Requires-Dist: tox; extra == "test"
+Requires-Dist: dkist-data-simulator; extra == "test"
+Provides-Extra: cli
+Requires-Dist: typer; extra == "cli"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-astropy; extra == "docs"
+Requires-Dist: sphinx-changelog; extra == "docs"
+Requires-Dist: sphinx-autoapi; extra == "docs"
+Requires-Dist: pytest; extra == "docs"
+Requires-Dist: towncrier; extra == "docs"
+Requires-Dist: dkist-sphinx-theme; extra == "docs"
+
+DKIST Data Validator
+====================
+
+|codecov|
+
+An interface containing a validator, and a spec translator for DKIST specs (specifically corresponding to SPEC122 RevE and SPEC214 RevA
+data):
+
+- SPEC-0122: Data received from the summit
+
+- SPEC-0214 l0: Data ingested and parsed by the Data Center
+
+- SPEC-0214: Data published by the Data Center (incomplete)
+
+The validator references a machine readable version of the DKIST Header Specifications which are defined `here <https://pypi.org/project/dkist-fits-specifications/>`__, in the dkist-fits-specifications. Unless otherwise specified, the latest version of dkist-fits-specifications package is installed along with the validator.  Data can be validated against past revisions of the DKIST Header Specifications if a previous version of the dkist-fits-specifications package is installed. If you are receiving validation errors, please reference the version of the DKIST Header Specifications identified in the dkist-fits-specifications package to make sure that your headers are expected to be compliant with that version.
+
+
+Features
+--------
+
+-  Uses `voluptuous <https://pypi.org/project/voluptuous/>`__ schemas to
+   validate a given input header against dkist specifications
+
+-  3 keyword validations: type validation, required-ness validation, and value validation
+
+-  Failure exceptions include a dictionary of validation failure causes
+
+-  SPEC-0122 to SPEC-0214 l0 translation
+
+
+Installation
+------------
+
+.. code:: bash
+
+   pip install dkist-header-validator
+
+
+Usage
+--------
+Currently, this package can be used to validate SPEC122 data or SPEC214 data. Please import the
+corresponding methods (spec122_validator and Spec122ValidationException, or spec214_validator and Spec214ValidationException, or spec214_l0_validator and Spec214ValidationException).
+
+This package can be used for validating data, or for validating and translating data (SPEC122 input only).
+
+Input data can be one of:
+    - string file path
+    - File like object
+    - HDUList object
+    - fits.header.Header object
+    - Dictionary of header keys and values
+
+To validate data:
+
+.. code:: python
+
+    >>> from dkist_header_validator import spec122_validator, Spec122ValidationException
+
+    >>> spec122_validator.validate('dkist_rosa0181200000_observation.fits')
+
+The cli can also be used to validate data:
+
+.. code:: bash
+
+    >>> dkist-header-validator validate122 "path/to/file.fits"
+
+    >>> dkist-header-validator validate214 "path/to/file.fits"
+
+To validate and translate data to spec214 l0:
+
+.. code:: python
+
+    >>> from dkist_header_validator import spec122_validator, Spec122ValidationException
+
+    >>> spec122_validator.validate_and_translate_to_214_l0('dkist_rosa0181200000_observation.fits')
+
+
+Within the validate and validate_and_translate methods, a series of flags can be set, otherwise they will take their default values:
+    - extra: Default value is true (allow extra keys). This flag determines if extra keywords are allowed in the schema to be validated. Ingest validation should allow extra keys.
+    - return_type: Default value is HDUList. This flag will determine the return type. Can be one of dict, Path, BytesIO, fits.header.Header, HDUList.
+
+
+Examples
+--------
+1. Validate a file:
+
+.. code:: python
+
+    >>> from dkist_header_validator import spec122_validator, Spec122ValidationException
+    >>> spec122_validator.validate('dkist_rosa0181200000_observation.fits', return_type=dict)
+
+    >>> from pathlib import Path
+    >>> spec122_validator.validate('dkist_rosa0181200000_observation.fits', return_type=Path)
+
+2. Validate and translate a file:
+
+.. code:: python
+
+    >>> from dkist_header_validator import spec122_validator, Spec122ValidationException
+    >>> spec122_validator.validate_and_translate_to_214_l0('dkist_rosa0181200000_observation.fits')
+
+
+3. Validate headers:
+
+.. code:: python
+
+    >>> from dkist_header_validator import spec122_validator, Spec122ValidationException
+    >>> from astropy.io import fits
+    >>> hdus = fits.open('dkist_rosa0181200000_observation.fits')
+    >>> spec122_validator.validate(hdus[0].header, return_type=dict)
+
+
+This project is Copyright (c) AURA/NSO.
+
+.. |codecov| image:: https://codecov.io/bb/dkistdc/dkist-header-validator/graph/badge.svg?token=OZK0ZPO2JH
+ :target: https://codecov.io/bb/dkistdc/dkist-header-validator

dkist_header_validator-5.2.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+dkist_header_validator/__init__.py,sha256=J4wfa3VQLsODIn0TDh_7KUwHcON8EofogFDTdctxFMw,421
+dkist_header_validator/base_validator.py,sha256=0WvVQfjDyoONQLWMg3GBdkj04hOVxTrR777V-mpIk0Y,27990
+dkist_header_validator/exceptions.py,sha256=8IA3xwntGjcJRyvzzgbD8Om0GxWtDY5kLnE3y8l_0Fw,1031
+dkist_header_validator/spec_validators.py,sha256=OUIRJ5xurRhBnxZ-8JhmuVcIusvK63gKSwPfwfGjJZE,1369
+dkist_header_validator/translator.py,sha256=gYjEQAF8IOB_pgWR9ZOlMlYUIl3P274gMaCI86qeqyw,9501
+dkist_header_validator/version.py,sha256=lxYXDAy7pRI_OFyrqEbD-imjq1dV35QX6WSrKzzluqY,345
+dkist_header_validator/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dkist_header_validator/api/validate.py,sha256=iU-alEp9rkV9oXAFmH253VFWbLyE8l-1K87XuJym1Ek,2219
+dkist_header_validator/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dkist_header_validator/tests/conftest.py,sha256=7ipuZ21rGEix9G5VXbMw1JXMGcpU4EqAuHAk3MpzKf4,22362
+dkist_header_validator/tests/test_base_validator.py,sha256=sSVeSLsjy6GnZK2vJ2O1BvZtnLsrOvOF6OVNVUGAARA,16213
+dkist_header_validator/tests/test_spec122_translation.py,sha256=D3molsOeMx4Dt6f4YAQKBJ2eZhEa1OV_PhM2zh5LmJ8,8670
+dkist_header_validator/tests/test_spec122_validation+.py,sha256=jxowHmQ6dwQt20r1vzgSsLgMXLlHGSg27AFv6fB8Bx0,4981
+dkist_header_validator/tests/test_spec122_validation-.py,sha256=Seg58VRwuswUj3-9wHwjQf3qXZ1aoNAaWposiPR7ALo,4242
+dkist_header_validator/tests/test_spec214_validation+.py,sha256=giuUlBcypMIptjOk0UdzeotzaImBRHld7SDSxH1lXxA,13832
+dkist_header_validator/tests/test_spec214_validation-.py,sha256=lzRGDZTF2H4MEG4b8mglGhit7jGpBCLWtf1qv1R7oNM,7475
+dkist_header_validator/tests/test_translator.py,sha256=6qiIxXJW1fq1UFHRljkwxEie6ya0QXEqtDz9PqJqbc4,4299
+dkist_header_validator/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dkist_header_validator/utils/expansions.py,sha256=cqT49UC0cqiP94jL7uZ5tnNNJAJ67BVNf8P82W4ipPA,1031
+dkist_header_validator-5.2.0.dist-info/METADATA,sha256=K9bpLHdzBBrP6b03dSDXnn01Rydl6Z7Wgch43OZeKPo,5608
+dkist_header_validator-5.2.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+dkist_header_validator-5.2.0.dist-info/entry_points.txt,sha256=H2575-kiHoXDKLmJxUHvzH9LK8qwG2ZW0TgH-67gU5Y,84
+dkist_header_validator-5.2.0.dist-info/top_level.txt,sha256=Xg2Mfa3AKhLk6lld6tmbUCP7HhME2_gsTOs6DYC08fQ,23
+dkist_header_validator-5.2.0.dist-info/RECORD,,

dkist_header_validator-5.2.0.dist-info/WHEEL

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

dkist_header_validator-5.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dkist-header-validator = dkist_header_validator.api.validate:main

dkist_header_validator-5.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dkist_header_validator