Serialize PSFs to ASDF files

.github/workflows/ci_tests.yml

@@ -140,3 +140,21 @@ jobs:
         token: ${{ secrets.CODECOV_TOKEN }}  # zizmor: ignore[secrets-outside-env]
         files: ./coverage.xml
         verbose: true
+  asdf-schemas:
+    name: Test ASDF Schemas
+    runs-on: ubuntu-latest
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6.0.2
+      with:
+        persist-credentials: false
+        fetch-depth: 0
+        path: photutils
+    - name: Set up Python 3.13
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405  # v6.2.0
+      with:
+        python-version: '3.13'
+    - name: Install dependencies
+      run: cd photutils && python -m pip install -e .[test]
+    - name: Validate ASDF schemas
+      run: cd photutils && pytest photutils/resources/schemas

photutils/converters/__init__.py

@@ -0,0 +1,25 @@
+from . apertures import CircularApertureConverter
+from .functional_models import (
+    AiryDiskPSFConverter,
+    CircularGaussianPRFConverter,
+    CircularGaussianPSFConverter,
+    CircularGaussianSigmaPRFConverter,
+    GaussianPRFConverter,
+    GaussianPSFConverter,
+    MoffatPSFConverter,
+)
+from . image_models import GriddedPSFConverter, ImagePSFConverter
+
+
+__all__ = [
+    'AiryDiskPSFConverter',
+    'CircularApertureConverter',
+    'CircularGaussianPRFConverter',
+    'CircularGaussianPSFConverter',
+    'CircularGaussianSigmaPRFConverter',
+    'GaussianPRFConverter',
+    'GaussianPSFConverter',
+    'GriddedPSFConverter',
+    'ImagePSFConverter',
+    'MoffatPSFConverter',
+]

photutils/converters/apertures.py

@@ -0,0 +1,37 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+"""
+Converters to and from the ASDF data format for photutils apertures.
+"""
+
+from asdf.extension import Converter
+
+__all__ = ['CircularApertureConverter']
+
+
+class CircularApertureConverter(Converter):
+    """
+    ASDF converter for CircularAperture.
+    """
+
+    tags = ('tag:astropy.org:photutils/aperture/circular_aperture-*',)
+    types = ('photutils.aperture.circle.CircularAperture',)
+
+    def to_yaml_tree(self, obj, tag, ctx):  # noqa: ARG002
+        if obj.positions.shape == (2,):
+            pos = obj.positions.tolist()
+        else:
+            pos = obj.positions
+
+        return {
+            'positions': pos,
+            'r': obj.r,
+        }
+
+    def from_yaml_tree(self, node, tag, ctx):  # noqa: ARG002
+        from photutils.aperture.circle import CircularAperture
+
+        return CircularAperture(
+            positions=node['positions'],
+            r=node['r'],
+        )

photutils/converters/functional_models.py

@@ -0,0 +1,230 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+"""
+Converters to and from the ASDF format for photutils.psf.functional_models.
+"""
+
+from asdf_astropy.converters.transform.core import (TransformConverterBase,
+                                                    parameter_to_value)
+
+__all__ = ['AiryDiskPSFConverter',
+           'CircularGaussianPRFConverter',
+           'CircularGaussianPSFConverter',
+           'CircularGaussianSigmaPRFConverter',
+           'GaussianPRFConverter',
+           'GaussianPSFConverter',
+           'MoffatPSFConverter',
+           ]
+
+
+class AiryDiskPSFConverter(TransformConverterBase):
+    """
+    Converter for AiryDiskPSF.
+    """
+
+    tags = ('tag:astropy.org:photutils/psf/airy_disk_psf-*',)
+    types = ('photutils.psf.AiryDiskPSF',)
+
+    def to_yaml_tree_transform(self, model, tag, ctx):  # noqa: ARG002
+        return {
+            'flux': parameter_to_value(model.flux),
+            'x_0': parameter_to_value(model.x_0),
+            'y_0': parameter_to_value(model.y_0),
+            'radius': parameter_to_value(model.radius),
+            'bbox_factor': model.bbox_factor,
+        }
+
+    def from_yaml_tree_transform(self, node, tag, ctx):  # noqa: ARG002
+        from photutils.psf import AiryDiskPSF
+
+        return AiryDiskPSF(
+            flux=node['flux'],
+            x_0=node['x_0'],
+            y_0=node['y_0'],
+            radius=node['radius'],
+            bbox_factor=node['bbox_factor'],
+        )
+
+
+class CircularGaussianPRFConverter(TransformConverterBase):
+    """
+    ASDF converter for CircularGaussianPRF model.
+    """
+
+    tags = ('tag:astropy.org:photutils/psf/circular_gaussian_prf-*',)
+    types = ('photutils.psf.CircularGaussianPRF',)
+
+    def to_yaml_tree_transform(self, model, tag, ctx):  # noqa: ARG002
+        return {
+            'flux': parameter_to_value(model.flux),
+            'x_0': parameter_to_value(model.x_0),
+            'y_0': parameter_to_value(model.y_0),
+            'fwhm': parameter_to_value(model.fwhm),
+            'bbox_factor': model.bbox_factor,
+        }
+
+    def from_yaml_tree_transform(self, node, tag, ctx):  # noqa: ARG002
+        from photutils.psf import CircularGaussianPRF
+
+        return CircularGaussianPRF(
+            flux=node['flux'],
+            x_0=node['x_0'],
+            y_0=node['y_0'],
+            fwhm=node['fwhm'],
+            bbox_factor=node['bbox_factor'],
+        )
+
+
+class CircularGaussianPSFConverter(TransformConverterBase):
+    """
+    ASDF converter for CircularGaussianPSF model.
+    """
+
+    tags = ('tag:astropy.org:photutils/psf/circular_gaussian_psf-*',)
+    types = ('photutils.psf.CircularGaussianPSF',)
+
+    def to_yaml_tree_transform(self, model, tag, ctx):  # noqa: ARG002
+        return {
+            'flux': parameter_to_value(model.flux),
+            'x_0': parameter_to_value(model.x_0),
+            'y_0': parameter_to_value(model.y_0),
+            'fwhm': parameter_to_value(model.fwhm),
+            'bbox_factor': model.bbox_factor,
+        }
+
+    def from_yaml_tree_transform(self, node, tag, ctx):  # noqa: ARG002
+        from photutils.psf import CircularGaussianPSF
+
+        return CircularGaussianPSF(
+            flux=node['flux'],
+            x_0=node['x_0'],
+            y_0=node['y_0'],
+            fwhm=node['fwhm'],
+            bbox_factor=node['bbox_factor'],
+        )
+
+
+class CircularGaussianSigmaPRFConverter(TransformConverterBase):
+    """
+    ASDF converter for CircularGaussianSigmaPRF model.
+    """
+
+    tags = ('tag:astropy.org:photutils/psf/circular_gaussian_sigma_prf-*',)
+    types = ('photutils.psf.CircularGaussianSigmaPRF',)
+
+    def to_yaml_tree_transform(self, model, tag, ctx):  # noqa: ARG002
+        return {
+            'flux': parameter_to_value(model.flux),
+            'x_0': parameter_to_value(model.x_0),
+            'y_0': parameter_to_value(model.y_0),
+            'sigma': parameter_to_value(model.sigma),
+            'bbox_factor': model.bbox_factor,
+        }
+
+    def from_yaml_tree_transform(self, node, tag, ctx):  # noqa: ARG002
+        from photutils.psf import CircularGaussianSigmaPRF
+
+        return CircularGaussianSigmaPRF(
+            flux=node['flux'],
+            x_0=node['x_0'],
+            y_0=node['y_0'],
+            sigma=node['sigma'],
+            bbox_factor=node['bbox_factor'],
+        )
+
+
+class GaussianPRFConverter(TransformConverterBase):
+    """
+    ASDF converter for GaussianPRF model.
+    """
+
+    tags = ('tag:astropy.org:photutils/psf/gaussian_prf-*',)
+    types = ('photutils.psf.GaussianPRF',)
+
+    def to_yaml_tree_transform(self, model, tag, ctx):  # noqa: ARG002
+        return {
+            'flux': parameter_to_value(model.flux),
+            'x_0': parameter_to_value(model.x_0),
+            'y_0': parameter_to_value(model.y_0),
+            'x_fwhm': parameter_to_value(model.x_fwhm),
+            'y_fwhm': parameter_to_value(model.y_fwhm),
+            'theta': parameter_to_value(model.theta),
+            'bbox_factor': model.bbox_factor,
+        }
+
+    def from_yaml_tree_transform(self, node, tag, ctx):  # noqa: ARG002
+        from photutils.psf import GaussianPRF
+
+        return GaussianPRF(
+            flux=node['flux'],
+            x_0=node['x_0'],
+            y_0=node['y_0'],
+            x_fwhm=node['x_fwhm'],
+            y_fwhm=node['y_fwhm'],
+            theta=node['theta'],
+            bbox_factor=node['bbox_factor'],
+        )
+
+
+class GaussianPSFConverter(TransformConverterBase):
+    """
+    ASDF converter for GaussianPSF model.
+    """
+
+    tags = ('tag:astropy.org:photutils/psf/gaussian_psf-*',)
+    types = ('photutils.psf.GaussianPSF',)
+
+    def to_yaml_tree_transform(self, model, tag, ctx):  # noqa: ARG002
+        return {
+            'flux': parameter_to_value(model.flux),
+            'x_0': parameter_to_value(model.x_0),
+            'y_0': parameter_to_value(model.y_0),
+            'x_fwhm': parameter_to_value(model.x_fwhm),
+            'y_fwhm': parameter_to_value(model.y_fwhm),
+            'theta': parameter_to_value(model.theta),
+            'bbox_factor': model.bbox_factor,
+        }
+
+    def from_yaml_tree_transform(self, node, tag, ctx):  # noqa: ARG002
+        from photutils.psf import GaussianPSF
+
+        return GaussianPSF(
+            flux=node['flux'],
+            x_0=node['x_0'],
+            y_0=node['y_0'],
+            x_fwhm=node['x_fwhm'],
+            y_fwhm=node['y_fwhm'],
+            theta=node['theta'],
+            bbox_factor=node['bbox_factor'],
+        )
+
+
+class MoffatPSFConverter(TransformConverterBase):
+    """
+    ASDF converter for MoffatPSF model.
+    """
+
+    tags = ('tag:astropy.org:photutils/psf/moffat_psf-*',)
+    types = ('photutils.psf.MoffatPSF',)
+
+    def to_yaml_tree_transform(self, model, tag, ctx):  # noqa: ARG002
+        return {
+            'flux': parameter_to_value(model.flux),
+            'x_0': parameter_to_value(model.x_0),
+            'y_0': parameter_to_value(model.y_0),
+            'alpha': parameter_to_value(model.alpha),
+            'beta': parameter_to_value(model.beta),
+            'bbox_factor': model.bbox_factor,
+        }
+
+    def from_yaml_tree_transform(self, node, tag, ctx):  # noqa: ARG002
+        from photutils.psf import MoffatPSF
+
+        return MoffatPSF(
+            flux=node['flux'],
+            x_0=node['x_0'],
+            y_0=node['y_0'],
+            alpha=node['alpha'],
+            beta=node['beta'],
+            bbox_factor=node['bbox_factor'],
+        )