Drop Reader and Writer base classes.

Author: TallJimbo

piff/interp.py

@@ -174,7 +174,7 @@ def interpolateList(self, stars, logger=None):
         return [ self.interpolate(star) for star in stars ]
 
     def write(self, writer, name):
-        """Write an Interp via a Writer object.
+        """Write an Interp via a writer object.
 
         Note: this only writes the initialization kwargs to the fits extension, not the parameters.
 
@@ -207,7 +207,7 @@ def _finish_write(self, writer):
 
     @classmethod
     def read(cls, reader, name):
-        """Read an Interp via a Reader object.
+        """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.

piff/outliers.py

@@ -91,7 +91,7 @@ def parseKwargs(cls, config_outliers, logger=None):
         return kwargs
 
     def write(self, writer, name):
-        """Write an Outers via a Writer object.
+        """Write an Outers via a writer object.
 
         :param writer:      A writer object that encapsulates the serialization format.
         :param name:        A name to associate with the Ootliers in the serialized output.

piff/psf.py

@@ -719,12 +719,12 @@ def write(self, file_name, logger=None):
         :param file_name:   The name of the file to write to.
         :param logger:      A logger object for logging debug info. [default: None]
         """
-        from .writers import Writer
+        from .writers import FitsWriter
 
         logger = galsim.config.LoggerWrapper(logger)
         logger.warning("Writing PSF to file %s",file_name)
 
-        with Writer.open(file_name) as w:
+        with FitsWriter.open(file_name) as w:
             self._write(w, 'psf', logger=logger)
 
     def _write(self, writer, name, logger):

piff/readers.py

@@ -18,126 +18,15 @@
 
 from contextlib import contextmanager
 
-import os
 import fitsio
 import galsim
 import numpy as np
 
 
-class Reader:
-    """An interface for reading that abstracts the serialization format.
+class FitsReader:
+    """A reader object that reads from to multiple FITS HDUs.
 
-    The `open` static method should be used to obtain the right reader for
-    a particular file based on its extension, but specific subclasses can be
-    constructed directly as well.
-
-    A `Reader` subclass is always paired with a `Writer` subclass, and the
-    methods of `Reader` each directly correspond to a method of `Writer`.
-
-    All `Reader` and `Writer` methods take a ``name`` argument that is
-    associated with the low-level data structured being saved.  When writing,
-    an object can chose not to write a subobject at all with a given name, and
-    then check to see if the corresponding `Reader` method returns `None`, but
-    a `Reader` cannot be used to see what type of data structure was saved with
-    a given name; if this can change, the write implementation must store this
-    explicitly and use it when invoking the `Reader`.
-    """
-
-    @staticmethod
-    @contextmanager
-    def open(file_name):
-        """Return a context manager that yields a `Reader` appropriate for the
-        given filename.
-
-        :param filename:   Name of the file to open (`str`).
-
-        :returns:  A context manager that yields a `Reader`.
-        """
-        _, ext = os.path.splitext(file_name)
-        if ext == ".fits" or ext == ".piff":
-            with FitsReader._open(file_name) as reader:
-                yield reader
-            return
-        else:
-            raise NotImplementedError(f"No reader for extension {ext!r}.")
-
-    def read_struct(self, name):
-        """Load a simple flat dictionary.
-
-        :param name:   Name used to save this struct in `Writer.write_struct`.
-
-        :returns:  A `dict` with `str` keys and `int`, `float`, `str`, `bool`,
-                   or `None` values.  If nothing was stored with the given
-                   name, `None` is returned.
-        """
-        raise NotImplementedError()
-
-    def read_table(self, name, metadata=None):
-        """Load a table as a numpy array.
-
-        :param name:      Name used to save this table in `Writer.write_table`.
-        :param metadata:  If not `None`, a `dict` to be filled with any
-                          metadata associated with the table on write.  Key
-                          case may not be preserved!
-
-        :returns:  A numpy array with a structured dtype, or `None` if no
-                   object with this name was saved.
-        """
-        raise NotImplementedError()
-
-    def read_array(self, name, metadata=None):
-        """Load a regular a numpy array that does not have a structured dtype.
-
-        :param name:      Name used to save this array in `Writer.write_array`.
-        :param metadata:  If not `None`, a `dict` to be filled with any
-                          metadata associated with the array on write.  Key
-                          case may not be preserved!
-
-        :returns:  A numpy array, or `None` if no object with this name was saved.
-        """
-        raise NotImplementedError()
-
-    def read_wcs_map(self, name, logger):
-        """Load a map of WCS objects and an optional pointing coord.
-
-        :param name:      Name used to save this map in `Writer.write_array`.
-        :param logger:    A logger object for logging debug info.
-
-        :returns:  A 2-element tuple, where the first entry is a `dict` with
-                   `int` (chipnum) keys and `galsim.BaseWCS` values, and the
-                   second entry is a `galsim.CelestialCoord` object.  Both
-                   entries may be `None`, and if the WCS `dict` is `None` the
-                   pointing coord is always `None`.
-        """
-        raise NotImplementedError()
-
-    def nested(self, name):
-        """Return a context manager that yields a new `Reader` that reads
-        content written by a similarly nested `Writer`.
-
-        :param name:     Base name for all objects read with the returned object.
-
-        :returns:     A context manager that yields a nested reader object.
-        """
-        raise NotImplementedError()
-
-    def get_full_name(self, name):
-        """Return the full name of a data structure saved with the given name,
-        combining it with any base names added if this `Reader` was created by
-        the `nested` method.
-        """
-        raise NotImplementedError()
-
-
-class FitsReader(Reader):
-    """A `Reader` implementation that reads from to multiple FITS HDUs.
-
-    This reader is intended to read files written by Piff before the `Reader`
-    and `Writer` abstractions were added.
-
-    `FitsReader.nested` yields a reader that reads from the same file and
-    prepends all names with its base name to form the EXTNAME, concatenating
-    them with ``_``.
+    This reader is intended to read files written by `FitsWriter`.
 
     :param fits:        An already-open `fitsio.FITS` object.
     :param base_name:   Base name to prepend to all object names, or `None`.
@@ -148,7 +37,7 @@ def __init__(self, fits, base_name):
 
     @classmethod
     @contextmanager
-    def _open(cls, file_name):
+    def open(cls, file_name):
         """Return a context manager that opens the given FITS file and yields
         a `FitsReader` object.
 
@@ -160,7 +49,14 @@ def _open(cls, file_name):
             yield cls(f, base_name=None)
 
     def read_struct(self, name):
-        # Docstring inherited.
+        """Load a simple flat dictionary.
+
+        :param name:   Name used to save this struct in `FitsWriter.write_struct`.
+
+        :returns:  A `dict` with `str` keys and `int`, `float`, `str`, `bool`,
+                   or `None` values.  If nothing was stored with the given
+                   name, `None` is returned.
+        """
         extname = self.get_full_name(name)
         if extname not in self._fits:
             return None
@@ -185,11 +81,28 @@ def read_struct(self, name):
         return struct
 
     def read_table(self, name, metadata=None):
-        # Docstring inherited.
+        """Load a table as a numpy array.
+
+        :param name:      Name used to save this table in `FitsWriter.write_table`.
+        :param metadata:  If not `None`, a `dict` to be filled with any
+                          metadata associated with the table on write.  Key
+                          case may not be preserved!
+
+        :returns:  A numpy array with a structured dtype, or `None` if no
+                   object with this name was saved.
+        """
         return self.read_array(name, metadata)
 
     def read_array(self, name, metadata=None):
-        # Docstring inherited.
+        """Load a regular a numpy array that does not have a structured dtype.
+
+        :param name:      Name used to save this array in `FitsWriter.write_array`.
+        :param metadata:  If not `None`, a `dict` to be filled with any
+                          metadata associated with the array on write.  Key
+                          case may not be preserved!
+
+        :returns:  A numpy array, or `None` if no object with this name was saved.
+        """
         extname = self.get_full_name(name)
         if extname not in self._fits:
             return None
@@ -198,7 +111,17 @@ def read_array(self, name, metadata=None):
         return self._fits[extname].read()
 
     def read_wcs_map(self, name, logger):
-        # Docstring inherited.
+        """Load a map of WCS objects and an optional pointing coord.
+
+        :param name:      Name used to save this map in `FitsWriter.write_wcs_map`.
+        :param logger:    A logger object for logging debug info.
+
+        :returns:  A 2-element tuple, where the first entry is a `dict` with
+                   `int` (chipnum) keys and `galsim.BaseWCS` values, and the
+                   second entry is a `galsim.CelestialCoord` object.  Both
+                   entries may be `None`, and if the WCS `dict` is `None` the
+                   pointing coord is always `None`.
+        """
         import base64
         import pickle
 
@@ -262,9 +185,21 @@ def read_wcs_map(self, name, logger):
 
     @contextmanager
     def nested(self, name):
-        # Docstring inherited.
+        """Return a context manager that yields a new `FitsReader` that reads
+        content written by a similarly nested `FitsWriter`.
+
+        :param name:     Base name for all objects read with the returned object.
+
+        :returns:     A context manager that yields a nested reader object.
+        """
         yield FitsReader(self._fits, base_name=self.get_full_name(name))
 
     def get_full_name(self, name: str) -> str:
-        # Docstring inherited.
+        """Return the full name of a data structure saved with the given name,
+        combining it with any base names added if this `FitsReader` was created
+        by the `nested` method.
+
+        The FITS implementation concatenates with ``_`` as a delimiter, and
+        uses the full name as the EXTNAME header value.
+        """
         return name if self._base_name is None else f"{self._base_name}_{name}"

piff/star.py

@@ -329,7 +329,7 @@ def makeTarget(cls, x=None, y=None, u=None, v=None, properties={}, wcs=None, sca
 
     @classmethod
     def write(cls, stars, writer, name):
-        """Write a list of stars to a Writer object.
+        """Write a list of stars to a writer object.
 
         :param stars:       A list of stars to write
         :param writer:      A writer object that encapsulates the serialization format.