test_gris.py

import os
import unittest
from datetime import datetime
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import patch

import numpy as np
import pandas as pd
from importer_test_data import gris_folder
from importer_test_data import test_data, hmi_context
from importer_test_data.gris_structure import (
    raw_files,
    folder as structured_gris_folder,
)

from kis_tools.gris.GrisArchive import GrisArchive
from kis_tools.gris.GrisDay import GrisDay
from kis_tools.gris.GrisFitsFile import GrisFitsFile
from kis_tools.gris.GrisRun import GrisRun
from kis_tools.gris.calib_settings.parsing import (
    parse_path,
    get_gris_calib_scripts,
    parse_file,
)
from kis_tools.gris.headers.wcs import reorder_gris_data
from kis_tools.util.util import groupby_gris_run

_testdata = "/dat/sdc/testing_data_for_importer/gris/"


class TestGris(unittest.TestCase):
    """Class to hold tests for gris importer"""

    @classmethod
    def setUpClass(cls):
        """global set up for tests"""

        cls.daytarget = gris_folder

        # setup targets for run-wise testing
        files = [str(p) for p in Path(cls.daytarget).glob("level1_split/*")]
        run, cls.runfiles = next(iter(groupby_gris_run(files).items()))
        # setup target for file-wise-testing
        cls.filetarget = cls.runfiles[0]

    def test_day(self):
        """test instatiation of GrisDay """
        # test instantiation with valid folder
        with patch(
            "kis_tools.util.util.date_from_fn", return_value=datetime(2014, 4, 26)
        ) as _:
            gd = GrisDay(self.daytarget)
        self.assertIsInstance(gd, GrisDay, "Instantiation of GrisDay class failed!")
        # test instantiation with folder like 20140426_1
        fakeday = GrisDay("20140426_1")
        self.assertIsInstance(
            fakeday,
            GrisDay,
            "Instantiation of GrisDay class failed on fake day!",
        )
        # test printing of object
        self.assertIsInstance(gd.__str__(), str)
        # test repr of object
        self.assertIsInstance(gd.__repr__(), str)
        # test printing of object
        self.assertIsInstance(fakeday.__str__(), str)
        # test repr of object
        self.assertIsInstance(fakeday.__repr__(), str)

        # test the count method
        self.assertGreater(gd.count("*"), 0)
        self.assertEqual(fakeday.count("*"), 0)

    def test_calib_parsing(self):
        """
        Test the toolkit for parsing gris calibration settings files.
        """

        # Test get_files
        files = [*get_gris_calib_scripts(structured_gris_folder)]
        assert files

        # test file_parsing
        calls = parse_file(files[0])
        assert calls

        # test recursive parsing
        call_df = parse_path(structured_gris_folder)
        assert isinstance(call_df, pd.DataFrame)

        # Try to parse an empty tempdir, ensure that an error is raised
        with self.assertRaises(ValueError):
            with TemporaryDirectory() as td:
                parse_path(td)

    def test_gris_fits_file(self):
        """test instantiation of GrisFitsFile """
        gff = GrisFitsFile(self.filetarget)
        self.assertIsInstance(gff, GrisFitsFile, "Instantiation of GrisFitsFile failed")
        # test parse function
        gff.parse()

        # test printing of object
        self.assertIsInstance(gff.__str__(), str)
        # test repr of object
        self.assertIsInstance(gff.__repr__(), str)

        # test make_bson
        self.assertIsInstance(gff.make_bson(), dict)

        # check that constructor complains on invalid filename
        with self.assertRaises(AssertionError):
            _ = GrisFitsFile("")

        # test repr
        print(repr(gff))
        print(gff)

        # test _coords_from_simple_header with file from 2017
        gf2 = GrisFitsFile(test_data.gris.l1_data[0])
        gf2.slit_orientation
        gf2.parse()
        gf2.telescope_centering
        _ = gf2.modestring
        _ = gf2._coords_from_simple_header

        # test coordinates from WCS
        self.assertEqual(len(gf2._coords_from_wcs.shape), 2)

        # test coordinates from translated and untranslated file
        translated_file = self.filetarget
        raw_file = raw_files[0]

        for f in [translated_file, raw_file]:
            coords = GrisFitsFile(f).coords
            self.assertTrue(coords)

    def test_gris_run(self):
        """test instantiation of GrisRun """
        myfiles = [GrisFitsFile(f) for f in self.runfiles]
        gr = GrisRun(myfiles)
        self.assertIsInstance(
            gr, GrisRun, "Instantiation of GrisRun from GrisFitsFiles failed"
        )

        # run @property functions once to test
        self.assertIsNotNone(gr.files_l0)
        self.assertIsNotNone(gr.files_l1)
        self.assertIsNotNone(gr.files_l1_split)
        self.assertIsNotNone(gr.files_l2)
        self.assertIsNotNone(gr.map_saves)

        gr = GrisRun(self.runfiles)
        self.assertIsInstance(gr, GrisRun, "Instantiation of GrisRun from Paths failed")

        gr.parse()

        # test printing of object
        self.assertIsInstance(gr.__str__(), str)

        # test repr of object
        self.assertIsInstance(gr.__repr__(), str)

        # test was aborted
        self.assertTrue(gr.was_aborted)

        # test observers
        obs = gr.observers
        self.assertTrue(obs)

        with patch(
            "kis_tools.util.locplot.get_hmi_continuum", return_value=hmi_context[0]
        ) as patched:
            fig, ax = gr.plot_location()
            self.assertEqual(len(ax.patches), 4)
            return fig, ax

    def test_gris_archive(self):
        """ test GrisArchive"""
        ga = GrisArchive(Path(self.daytarget).parent)
        self.assertIsInstance(
            ga, GrisArchive, "Could not instantiate gris archive class"
        )
        df = ga.get_df()
        self.assertGreater(len(df), 0)

    def test_wcs(self):

        # Test reordering of data
        test_shapes = [
            (4, 166, 1010),  # polarimetric  data
            (493, 1010),  # spectroscopic data
        ]
        for shape in test_shapes:
            data = np.zeros(shape)
            reordered = reorder_gris_data(data, reverse_axes=False)
            reordered_rev = reorder_gris_data(data, reverse_axes=True)

            # check that something has been done
            self.assertNotEqual(data.shape, reordered.shape)

            # check the correct order of spatial axes
            shape = reordered.shape
            self.assertLess(shape[0], shape[1])

            # check that reversed data is the reverse of normal data
            self.assertEqual(reordered.shape[::-1], reordered_rev.shape)

            # check that the maximum (spectral axis) is at third position
            self.assertEqual(2, shape.index(max(shape)))


if __name__ == "__main__":
    with open(os.devnull, "w") as log:
        unittest.main()