Refactor read methods to delegate to new Reader interface.

Author: TallJimbo

piff/__init__.py

@@ -120,4 +120,5 @@
 from . import des
 from . import wavefront
 from . import meta_data
+from . import readers
 from . import writers

piff/basis_interp.py

@@ -447,12 +447,12 @@ def _finish_write(self, writer):
         data['q'] = self.q
         writer.write_table('solution', data)
 
-    def _finish_read(self, fits, extname):
-        """Read the solution from a FITS binary table.
+    def _finish_read(self, reader):
+        """Read the solution.
 
-        :param fits:        An open fitsio.FITS object.
-        :param extname:     The name of the extension with the interpolator information.
+        :param reader:      A reader object that encapsulates the serialization format.
         """
-        data = fits[extname + '_solution'].read()
+        data = reader.read_table('solution')
+        assert data is not None
         self.q = data['q'][0]
 

piff/convolvepsf.py

@@ -20,7 +20,6 @@
 import galsim
 
 from .psf import PSF
-from .util import read_kwargs
 from .star import Star, StarFit
 from .outliers import Outliers
 
@@ -292,24 +291,20 @@ def _finish_write(self, writer, logger):
             self.outliers._write(writer, 'outliers')
             logger.debug("Wrote the PSF outliers to extension %s", writer.get_full_name('outliers'))
 
-    def _finish_read(self, fits, extname, logger):
+    def _finish_read(self, reader, logger):
         """Finish the reading process with any class-specific steps.
 
-        :param fits:        An open fitsio.FITS object
-        :param extname:     The base name of the extension to write to.
+        :param reader:      A reader object that encapsulates the serialization format.
         :param logger:      A logger object for logging debug info.
         """
-        chisq_dict = read_kwargs(fits, extname + '_chisq')
+        chisq_dict = reader.read_struct('chisq')
         for key in chisq_dict:
             setattr(self, key, chisq_dict[key])
 
         ncomponents = self.components
         self.components = []
         for k in range(ncomponents):
-            self.components.append(PSF._read(fits, extname + '_' + str(k), logger=logger))
-        if extname + '_outliers' in fits:
-            self.outliers = Outliers.read(fits, extname + '_outliers')
-        else:
-            self.outliers = None
+            self.components.append(PSF._read(reader, str(k), logger=logger))
+        self.outliers = Outliers._read(reader, 'outliers')
         # Set up all the num's properly now that everything is constructed.
         self.set_num(None)

piff/des/decam_wavefront.py

@@ -176,13 +176,13 @@ def _finish_write(self, writer):
         # write to fits
         writer.write_table('solution', data)
 
-    def _finish_read(self, fits, extname):
-        """Read the solution from a FITS binary table.
+    def _finish_read(self, reader):
+        """Read the solution.
 
-        :param fits:        An open fitsio.FITS object.
-        :param extname:     The name of the extension with the interp information.
+        :param reader:      A reader object that encapsulates the serialization format.
         """
-        data = fits[extname + '_solution'].read()
+        data = reader.read_table('solution')
+        assert data is not None
 
         # self.locations and self.targets assigned in _fit
         self._fit(data['LOCATIONS'][0], data['TARGETS'][0])

piff/gp_interp.py

@@ -321,13 +321,13 @@ def _finish_write(self, writer):
 
         writer.write_table('kernel', data)
 
-    def _finish_read(self, fits, extname):
+    def _finish_read(self, reader):
         """Finish the reading process with any class-specific steps.
 
-        :param fits:        An open fitsio.FITS object.
-        :param extname:     The base name of the extension.
+        :param reader:      A reader object that encapsulates the serialization format.
         """
-        data = fits[extname+'_kernel'].read()
+        data = reader.read_table('kernel')
+        assert data is not None
         # Run fit to set up GP, but don't actually do any hyperparameter optimization. Just
         # set the GP up using the current hyperparameters.
         # Need to give back average fits files if needed.

piff/interp.py

@@ -17,7 +17,6 @@
 """
 
 import numpy as np
-from .util import read_kwargs
 
 class Interp(object):
     """The base class for interpolating a set of data vectors across the field of view.
@@ -227,36 +226,39 @@ def read(cls, fits, extname):
 
         :returns: an interpolator built with a information in the FITS file.
         """
-        assert extname in fits
-        assert 'type' in fits[extname].get_colnames()
-        assert 'type' in fits[extname].read().dtype.names
-        # interp_type = fits[extname].read_column('type')
-        interp_type = fits[extname].read()['type']
-        assert len(interp_type) == 1
-        try:
-            interp_type = str(interp_type[0].decode())
-        except AttributeError:
-            # fitsio 1.0 returns strings
-            interp_type = interp_type[0]
+        from .readers import FitsReader
+        return cls._read(FitsReader(fits, None), extname)
+
+    @classmethod
+    def _read(cls, reader, name):
+        """Read an Interp via a Reader object.
+
+        :param reader:      A reader object that encapsulates the serialization format.
+        :param name:        Name associated with this interpolator in the serialized output.
+
+        :returns: an interpolator built from serialized information.
+        """
+        kwargs = reader.read_struct(name)
+        assert kwargs is not None
+        assert 'type' in kwargs
+        interp_type = kwargs.pop('type')
 
         # Check that interp_type is a valid Interp type.
         if interp_type not in Interp.valid_interp_types:
             raise ValueError("interp type %s is not a valid Piff Interpolation"%interp_type)
         interp_cls = Interp.valid_interp_types[interp_type]
 
-        kwargs = read_kwargs(fits, extname)
-        kwargs.pop('type',None)
         interp = interp_cls(**kwargs)
-        interp._finish_read(fits, extname)
+        with reader.nested(name) as r:
+            interp._finish_read(r)
         return interp
 
-    def _finish_read(self, fits, extname):
+    def _finish_read(self, reader):
         """Finish the reading process with any class-specific steps.
 
         The base class implementation doesn't do anything, but this will probably always be
         overridden by the derived class.
 
-        :param fits:        An open fitsio.FITS object.
-        :param extname:     The base name of the extension.
+        :param reader:      A reader object that encapsulates the serialization format.
         """
         raise NotImplementedError("Derived classes must define the _finish_read method.")

piff/knn_interp.py

@@ -174,13 +174,12 @@ def _finish_write(self, writer):
 
         writer.write_table('solution', data)
 
-    def _finish_read(self, fits, extname):
-        """Read the solution from a FITS binary table.
+    def _finish_read(self, reader):
+        """Read the solution.
 
-        :param fits:        An open fitsio.FITS object.
-        :param extname:     The base name of the extension with the interp information.
+        :param reader:      A reader object that encapsulates the serialization format.
         """
-        data = fits[extname + '_solution'].read()
+        data = reader.read_table('solution')
 
         # self.locations and self.targets assigned in _fit
         self._fit(data['LOCATIONS'][0], data['TARGETS'][0])

piff/mean_interp.py

@@ -70,11 +70,11 @@ def _finish_write(self, writer):
         data = np.array(list(zip(*cols)), dtype=dtypes)
         writer.write_table('solution', data)
 
-    def _finish_read(self, fits, extname):
-        """Read the solution from a FITS binary table.
+    def _finish_read(self, reader):
+        """Read the solution.
 
-        :param fits:        An open fitsio.FITS object.
-        :param extname:     The base name of the extension
+        :param reader:      A reader object that encapsulates the serialization format.
         """
-        data = fits[extname + '_solution'].read()
+        data = reader.read_table('solution')
+        assert data is not None
         self.mean = data['mean']

piff/model.py

@@ -16,7 +16,6 @@
 .. module:: model
 """
 
-from .util import read_kwargs
 from .star import Star
 
 
@@ -204,29 +203,37 @@ def read(cls, fits, extname):
 
         :returns: a model built with a information in the FITS file.
         """
-        assert extname in fits
-        assert 'type' in fits[extname].get_colnames()
-        model_type = fits[extname].read()['type']
-        assert len(model_type) == 1
-        try:
-            model_type = str(model_type[0].decode())
-        except AttributeError:
-            # fitsio 1.0 returns strings
-            model_type = model_type[0]
+        from .readers import FitsReader
+        return cls._read(FitsReader(fits, None), extname)
+
+    @classmethod
+    def _read(cls, reader, name):
+        """Read a Model from a FITS file.
+
+        Note: the returned Model will not have its parameters set.  This just initializes a fresh
+        model that can be used to interpret interpolated vectors.
+
+        :param reader:      A reader object that encapsulates the serialization format.
+        :param name:        Name associated with this model in the serialized output.
+
+        :returns: a model built with a information in the FITS file
+        """
+        kwargs = reader.read_struct(name)
+        assert kwargs is not None
+        assert 'type' in kwargs
+        model_type = kwargs.pop('type')
 
         # Check that model_type is a valid Model type.
         if model_type not in Model.valid_model_types:
             raise ValueError("model type %s is not a valid Piff Model"%model_type)
         model_cls = Model.valid_model_types[model_type]
 
-        kwargs = read_kwargs(fits, extname)
-        kwargs.pop('type',None)
         if 'force_model_center' in kwargs: # pragma: no cover
             # old version of this parameter name.
             kwargs['centered'] = kwargs.pop('force_model_center')
         model_cls._fix_kwargs(kwargs)
         model = model_cls(**kwargs)
-        model._finish_read(fits, extname)
+        model._finish_read(reader)
         return model
 
     @classmethod
@@ -243,14 +250,13 @@ def _fix_kwargs(cls, kwargs):
         """
         pass
 
-    def _finish_read(self, fits, extname):
+    def _finish_read(self, reader):
         """Finish the reading process with any class-specific steps.
 
         The base class implementation doesn't do anything, which is often appropriate, but
         this hook exists in case any Model classes need to read extra information from the
         fits file.
 
-        :param fits:        An open fitsio.FITS object.
-        :param extname:     The base name of the extension.
+        :param reader:      A reader object that encapsulates the serialization format.
         """
         pass

piff/outliers.py

@@ -22,7 +22,6 @@
 import galsim
 from scipy.stats import chi2
 
-from .util import read_kwargs
 
 class Outliers(object):
     """The base class for handling outliers.
@@ -135,15 +134,25 @@ def read(cls, fits, extname):
 
         :returns: an Outliers handler
         """
-        assert extname in fits
-        assert 'type' in fits[extname].get_colnames()
-        outliers_type = fits[extname].read()['type']
-        assert len(outliers_type) == 1
-        try:
-            outliers_type = str(outliers_type[0].decode())
-        except AttributeError:
-            # fitsio 1.0 returns strings
-            outliers_type = outliers_type[0]
+        from .readers import FitsReader
+        result = cls._read(FitsReader(fits, None), extname)
+        assert result is not None
+        return result
+
+    @classmethod
+    def _read(cls, reader, name):
+        """Read a Outliers from a FITS file.
+
+        :param reader:      A reader object that encapsulates the serialization format.
+        :param name:        Name associated with the outliers in the serialized output.
+
+        :returns: an Outliers handler, or None if there isn't one.
+        """
+        kwargs = reader.read_struct(name)
+        if kwargs is None:
+            return None
+        assert 'type' in kwargs
+        outliers_type = kwargs.pop('type')
 
         # Old output files had the full name.  Fix it if necessary.
         if (outliers_type.endswith('Outliers')
@@ -155,21 +164,19 @@ def read(cls, fits, extname):
             raise ValueError("outliers type %s is not a valid Piff Outliers"%outliers_type)
         outliers_cls = Outliers.valid_outliers_types[outliers_type]
 
-        kwargs = read_kwargs(fits, extname)
-        kwargs.pop('type',None)
         outliers = outliers_cls(**kwargs)
-        outliers._finish_read(fits, extname)
+        with reader.nested(name) as r:
+            outliers._finish_read(r)
         return outliers
 
-    def _finish_read(self, fits, extname):
+    def _finish_read(self, reader):
         """Finish the reading process with any class-specific steps.
 
         The base class implementation doesn't do anything, which is often appropriate, but
         this hook exists in case any Outliers classes need to read extra information from the
         fits file.
 
-        :param fits:        An open fitsio.FITS object.
-        :param extname:     The base name of the extension.
+        :param reader:      A reader object that encapsulates the serialization format.
         """
         pass
 

piff/polynomial_interp.py

@@ -370,17 +370,16 @@ def _finish_write(self, writer):
         writer.write_table('solution', data, metadata=header)
 
 
-    def _finish_read(self, fits, extname):
-        """Read the solution from a fits file.
+    def _finish_read(self, reader):
+        """Read the solution.
 
-        :param fits:        An open fitsio.FITS object.
-        :param extname:     The base name of the extension
+        :param reader:      A reader object that encapsulates the serialization format.
         """
         # Read the solution extension.
-        data = fits[extname + '_solution'].read()
-        header = fits[extname + '_solution'].read_header()
-
-        self.nparam = header['NPARAM']
+        metadata = {}
+        data = reader.read_table('solution', metadata=metadata)
+        assert data is not None
+        self.nparam = metadata['NPARAM']
 
         # Run setup functions to get these values right.
         self._set_function(self.poly_type)