Remove TICA option from TESS footprint cutouts, deprecate product parameter (#161)

* Remove from footprint cutouts, deprecate product parameter

* fix test bug

* Deprecation in other classes, update docs

* Docs note

* Update changelog

Author: snbianco

CHANGES.rst

@@ -8,6 +8,10 @@
 - By default, ASDF cutouts now preserve all metadata from the input file. [#158]
 - Add ``lite`` parameter to ``ASDFCutout`` to create minimal cutouts with only the science data and updated world coordinate system. [#158]
 - Add history entry to ASDF cutouts specifying the cutout shape and center coordinates. [#158]
+- Remove TICA (TESS Image Calibration) as an option for the ``product`` parameter in ``TessFootprintCutout``. [#161]
+- Deprecate the ``TicaCubeFactory`` class. [#161]
+- Deprecate the ``product`` parameter in the ``TessCubeCutout`` class, the ``TessFootprintCutout`` class, the ``cube_cut`` function,
+  the ``CutoutFactory.cube_cut`` function, and the ``cube_cutout_from_footprint`` function. [#161]
 
 
 1.0.1 (2025-05-12)

astrocut/cube_factory.py

@@ -44,8 +44,8 @@ class CubeFactory():
         Updates an existing cube file with new FITS images.
     """
 
-    ERROR_MSG = ('One or more incorrect file types were input. Please input TICA FFI files when using '
-                 '``TicaCubeFactory``, and SPOC FFI files when using ``CubeFactory``.')
+    ERROR_MSG = ('One or more incorrect file types were input. Please input only SPOC FFI files when '
+                 'using ``CubeFactory``.')
 
     def __init__(self, max_memory: int = 50):
         """ Setting up the class members """

astrocut/cutout_factory.py

@@ -8,6 +8,7 @@
 import astropy.units as u
 import numpy as np
 from astropy.coordinates import SkyCoord
+from astropy.utils.decorators import deprecated_renamed_argument
 from s3path import S3Path
 
 from .tess_cube_cutout import TessCubeCutout
@@ -18,14 +19,16 @@ class CutoutFactory():
     Class for creating image cutouts from TESS image cube files.
 
     This class encompasses all of the cutout functionality.  
-    In the current version this means creating cutout target pixel files from both 
-    SPOC (Science Processing Operations Center) and TICA (Tess Image CAlibration) 
-    full frame image cubes.
+    In the current version, this means creating cutout target pixel files from 
+    TESS full frame images cubes.
 
     This class is maintained for backwards compatibility. For maximum flexibility, we recommend using the
     `~astrocut.TessCubeCutout` class.
     """
 
+    @deprecated_renamed_argument('product', None, since='1.1.0', message='The `product` argument is deprecated and '
+                                 'will be removed in a future version. Astrocut will only support cutouts from '
+                                 'SPOC products.')
     def cube_cut(self, cube_file: Union[str, Path, S3Path], coordinates: Union[SkyCoord, str],
                  cutout_size: Union[int, np.ndarray, u.Quantity, List[int], Tuple[int]], 
                  product: str = 'SPOC', target_pixel_file: Optional[str] = None, 
@@ -57,8 +60,9 @@ def cube_cut(self, cube_file: Union[str, Path, S3Path], coordinates: Union[SkyCo
             units of pixels. `~astropy.units.Quantity` objects must be in pixel or
             angular units.
         product : str
-            The product type to make the cutouts from.
-            Can either be 'SPOC' or 'TICA' (default is 'SPOC').
+            .. deprecated:: 1.1.0
+               This parameter is deprecated and will be removed in a future release.
+               Only "SPOC" products will be supported.
         target_pixel_file : str
             Optional. The name for the output target pixel file.
             If no name is supplied, the file will be named:
@@ -104,7 +108,8 @@ def cube_cut(self, cube_file: Union[str, Path, S3Path], coordinates: Union[SkyCo
                                         output_file=target_pixel_file)[0]
 
 
-
+@deprecated_renamed_argument('product', None, since='1.1.0', message='The `product` argument is deprecated and will be '
+                             'removed in a future version. Astrocut will only support cutouts from SPOC products.')
 def cube_cut(cube_file: Union[str, Path, S3Path], coordinates: Union[SkyCoord, str],
              cutout_size: Union[int, np.ndarray, u.Quantity, List[int], Tuple[int]], 
              product: str = 'SPOC', target_pixel_file: Optional[str] = None, 
@@ -136,8 +141,9 @@ def cube_cut(cube_file: Union[str, Path, S3Path], coordinates: Union[SkyCoord, s
         units of pixels. `~astropy.units.Quantity` objects must be in pixel or
         angular units.
     product : str
-        The product type to make the cutouts from.
-        Can either be 'SPOC' or 'TICA' (default is 'SPOC').
+        .. deprecated:: 1.1.0
+           This parameter is deprecated and will be removed in a future release.
+           Only "SPOC" products will be supported.
     target_pixel_file : str
         Optional. The name for the output target pixel file.
         If no name is supplied, the file will be named:

astrocut/tess_cube_cutout.py

@@ -8,6 +8,7 @@
 from astropy.coordinates import SkyCoord
 from astropy.io import fits
 from astropy.time import Time
+from astropy.utils.decorators import deprecated_renamed_argument
 from astropy.wcs import WCS
 from s3path import S3Path
 
@@ -36,8 +37,9 @@ class TessCubeCutout(CubeCutout):
         The number of threads to use for making the cutouts. If 'auto', the number of threads will be set to the number
         of available CPUs.
     product : str
-        The product type to make the cutouts from.
-        Can either be 'SPOC' or 'TICA' (default is 'SPOC').
+        .. deprecated:: 1.1.0
+           This parameter is deprecated and will be removed in a future release.
+           Only "SPOC" products will be supported.
     verbose : bool
         If True, log messages are printed to the console.
 
@@ -60,6 +62,9 @@ class TessCubeCutout(CubeCutout):
         Write the cutouts to target pixel files.
     """
 
+    @deprecated_renamed_argument('product', None, since='1.1.0', message='The `product` argument is deprecated and '
+                                 'will be removed in a future version. Astrocut will only support cutouts from '
+                                 'SPOC products.')
     def __init__(self, input_files: List[Union[str, Path, S3Path]], coordinates: Union[SkyCoord, str], 
                  cutout_size: Union[int, np.ndarray, u.Quantity, List[int], Tuple[int]] = 25,
                  fill_value: Union[int, float] = np.nan, limit_rounding_method: str = 'round', 

astrocut/tess_footprint_cutout.py

@@ -6,6 +6,7 @@
 import numpy as np
 from astropy.coordinates import SkyCoord
 from astropy.io.fits import HDUList
+from astropy.utils.decorators import deprecated_renamed_argument
 from astropy.table import Table
 
 from . import log
@@ -35,7 +36,9 @@ class TessFootprintCutout(FootprintCutout):
         cutouts will be generated from all sequences that contain the cutout.
         For the TESS mission, this parameter corresponds to sectors.
     product : str, optional
-        Default 'SPOC'. The product type to make the cutouts from.
+        .. deprecated:: 1.1.0
+           This parameter is deprecated and will be removed in a future release.
+           Only "SPOC" products are now supported.
     verbose : bool
         If True, log messages are printed to the console.
 
@@ -62,25 +65,24 @@ class TessFootprintCutout(FootprintCutout):
         Write the cutouts as Target Pixel Files (TPFs) to the specified directory.
     """
 
+    @deprecated_renamed_argument('product', None, since='1.1.0', message='Astrocut no longer supports cutouts from '
+                                 'TESS Image Calibrator (TICA) products. '
+                                 'The `product` argument is deprecated and will be removed in a future version.')
     def __init__(self, coordinates: Union[SkyCoord, str], 
                  cutout_size: Union[int, np.ndarray, u.Quantity, List[int], Tuple[int]] = 25,
                  fill_value: Union[int, float] = np.nan, limit_rounding_method: str = 'round', 
                  sequence: Union[int, List[int], None] = None, product: str = 'SPOC', verbose: bool = False):
         super().__init__(coordinates, cutout_size, fill_value, limit_rounding_method, sequence, verbose)
 
         # Validate and set the product
-        if product.upper() not in ['SPOC', 'TICA']:
-            raise InvalidInputError('Product for TESS cube cutouts must be either "SPOC" or "TICA".')
-        self._product = product.upper()
+        if product.upper() != 'SPOC':
+            raise InvalidInputError('Product for TESS cube cutouts must be "SPOC".')
+        self._product = 'SPOC'
         self._arcsec_per_px = 21  # Number of arcseconds per pixel in a TESS image
 
-        # Set S3 URIs to footprint cache file and base file path based on product
-        if self._product == 'SPOC':
-            self._s3_footprint_cache = 's3://stpubdata/tess/public/footprints/tess_ffi_footprint_cache.json'
-            self._s3_base_file_path = 's3://stpubdata/tess/public/mast/'
-        else:
-            self._s3_footprint_cache = 's3://stpubdata/tess/public/footprints/tica_ffi_footprint_cache.json'
-            self._s3_base_file_path = 's3://stpubdata/tess/public/mast/tica/'
+        # Set S3 URIs to footprint cache file and base file path
+        self._s3_footprint_cache = 's3://stpubdata/tess/public/footprints/tess_ffi_footprint_cache.json'
+        self._s3_base_file_path = 's3://stpubdata/tess/public/mast/'
 
         # Make the cutouts upon initialization
         self.cutout()
@@ -99,14 +101,8 @@ def _extract_sequence_information(self, sector_name: str) -> dict:
         dict
             A dictionary containing the sector name, sector number, camera number, and CCD number.
         """
-        # Define the pattern based on the product
-        if self._product == 'SPOC':
-            pattern = re.compile(r"(tess-s)(?P<sector>\d{4})-(?P<camera>\d{1,4})-(?P<ccd>\d{1,4})")
-        elif self._product == 'TICA':
-            pattern = re.compile(r"(hlsp_tica_s)(?P<sector>\d{4})-(cam)(?P<camera>\d{1,4})-(ccd)(?P<ccd>\d{1,4})")
-        else:
-            # Return an empty dictionary if the product is not recognized
-            return {}
+        # Example sector name format: "tess-s0001-4-4"
+        pattern = re.compile(r"(tess-s)(?P<sector>\d{4})-(?P<camera>\d{1,4})-(?P<ccd>\d{1,4})")
         sector_match = re.match(pattern, sector_name)
 
         if not sector_match:
@@ -118,10 +114,6 @@ def _extract_sequence_information(self, sector_name: str) -> dict:
         camera = sector_match.group("camera")
         ccd = sector_match.group("ccd")
 
-        # Rename the TICA sector because of the naming convention in Astrocut
-        if self._product == 'TICA':
-            sector_name = f"tica-s{sector}-{camera}-{ccd}"
-
         return {"sectorName": sector_name, "sector": sector, "camera": camera, "ccd": ccd}
 
     def _create_sequence_list(self, observations: Table) -> List[dict]:
@@ -139,8 +131,7 @@ def _create_sequence_list(self, observations: Table) -> List[dict]:
             A list of dictionaries, each containing the sector name, sector number, camera number, and CCD number.
         """
         # Filter observations by target name to get only the FFI observations
-        target_name = "TESS FFI" if self._product == 'SPOC' else "TICA FFI"
-        obs_filtered = [obs for obs in observations if obs["target_name"].upper() == target_name]
+        obs_filtered = [obs for obs in observations if obs["target_name"].upper() == "TESS FFI"]
 
         sequence_results = []
         for row in obs_filtered:
@@ -220,7 +211,7 @@ def cutout(self):
         input_files = [f"{self._s3_base_file_path}{file['cube']}" for file in files_mapping]
         tess_cube_cutout = TessCubeCutout(input_files, self._coordinates, self._cutout_size, 
                                           self._fill_value, self._limit_rounding_method, threads=8, 
-                                          product=self._product, verbose=self._verbose)
+                                          verbose=self._verbose)
 
         # Assign attributes from the TessCubeCutout object
         self.tess_cube_cutout = tess_cube_cutout
@@ -244,8 +235,11 @@ def write_as_tpf(self, output_dir: Union[str, Path] = '.') -> List[str]:
             List of file paths to cutout target pixel files.
         """
         return self.tess_cube_cutout.write_as_tpf(output_dir)
-    
 
+
+@deprecated_renamed_argument('product', None, since='1.1.0', message='Astrocut no longer supports cutouts from '
+                             'TESS Image Calibrator (TICA) products. '
+                             'The `product` argument is deprecated and will be removed in a future version.')
 def cube_cut_from_footprint(coordinates: Union[str, SkyCoord], cutout_size, 
                             sequence: Union[int, List[int], None] = None, product: str = 'SPOC',
                             memory_only=False, output_dir: str = '.', 
@@ -273,7 +267,9 @@ def cube_cut_from_footprint(coordinates: Union[str, SkyCoord], cutout_size,
         cutouts will be generated from all sequences that contain the cutout.
         For the TESS mission, this parameter corresponds to sectors.
     product : str, optional
-        Default 'SPOC'. The product type to make the cutouts from.
+        .. deprecated:: 1.1.0
+           This parameter is deprecated and will be removed in a future release.
+           Only "SPOC" products are now supported.
     memory_only : bool, optional
         Default False. If True, the cutouts are stored in memory and not written to disk.
     output_dir : str, optional
@@ -295,7 +291,6 @@ def cube_cut_from_footprint(coordinates: Union[str, SkyCoord], cutout_size,
     ...         coordinates='83.40630967798376 -62.48977125108528',
     ...         cutout_size=64,
     ...         sequence=[1, 2],  # TESS sectors
-    ...         product='SPOC',
     ...         output_dir='./cutouts')
     ['./cutouts/tess-s0001-4-4/tess-s0001-4-4_83.406310_-62.489771_64x64_astrocut.fits',
      './cutouts/tess-s0002-4-1/tess-s0002-4-1_83.406310_-62.489771_64x64_astrocut.fits']

astrocut/tests/test_cube_factory.py

@@ -182,8 +182,7 @@ def test_invalid_inputs(tmpdir, ffi_type, img_size, num_images):
     """
     # Assigning some variables
     product = 'TICA' if ffi_type == 'TICA' else 'SPOC'
-    value_error = ('One or more incorrect file types were input. Please input TICA FFI files when using '
-                   '``TicaCubeFactory``, and SPOC FFI files when using ``CubeFactory``.')
+    value_error = ('One or more incorrect file types were input.')
 
     # Create test FFI files
     ffi_files = create_test_ffis(img_size=img_size, 

astrocut/tests/test_tess_footprint_cutout.py

@@ -26,13 +26,12 @@ def coordinates():
     return SkyCoord('350 -80', unit='deg')
 
 
-def check_output_tpf(tpf, ffi_type, sequences=[], cutout_size=5):
+def check_output_tpf(tpf, sequences=[], cutout_size=5):
     """Helper function to check the validity of output cutout files"""
     tpf_table = tpf[1].data
 
     # SPOC cutouts have 1 extra columns in EXT 1
-    ncols = 12 if ffi_type == 'SPOC' else 11
-    assert len(tpf_table.columns) == ncols
+    assert len(tpf_table.columns) == 12
     assert tpf_table[0]['FLUX'].shape == (cutout_size, cutout_size)
 
     # Check that sector matches a provided sequence
@@ -78,10 +77,9 @@ def test_ffi_intersect(lon, lat, center, expected):
     assert intersection.value[0] == expected
 
 
-@pytest.mark.parametrize('ffi_type', ['SPOC', 'TICA'])
-def test_tess_footprint_cutout(cutout_size, caplog, ffi_type):
+def test_tess_footprint_cutout(cutout_size, caplog):
     """Test that a single data cube is created for a given sequence"""
-    cutout = TessFootprintCutout('130 30', cutout_size, product=ffi_type, sequence=44, verbose=True)
+    cutout = TessFootprintCutout('130 30', cutout_size, sequence=44, verbose=True)
 
     # Check cutouts attribute
     cutouts = cutout.cutouts
@@ -101,15 +99,15 @@ def test_tess_footprint_cutout(cutout_size, caplog, ffi_type):
     assert len(tpf_cutouts) == 1
     assert isinstance(tpf_cutouts, list)
     assert isinstance(tpf_cutouts[0], fits.HDUList)
-    check_output_tpf(tpf_cutouts[0], ffi_type, [44])
+    check_output_tpf(tpf_cutouts[0], [44])
 
     # Check tpf_cutouts_by_file
     tpf_cutouts_by_file = cutout.tpf_cutouts_by_file
     tpf_cutout = list(tpf_cutouts_by_file.values())[0]
     assert len(tpf_cutouts_by_file) == 1
     assert isinstance(tpf_cutouts_by_file, dict)
     assert isinstance(tpf_cutout, fits.HDUList)
-    check_output_tpf(tpf_cutout, ffi_type, [44])
+    check_output_tpf(tpf_cutout, [44])
 
     # Check tess_cube attribute
     tess_cube = cutout.tess_cube_cutout
@@ -125,8 +123,8 @@ def test_tess_footprint_cutout(cutout_size, caplog, ffi_type):
     assert 'Generating cutouts...' in captured
 
     # Check that _extract_sequence_information works correctly
-    # Should return empty dict if sector name does not match product
-    sector_name = 'hlsp_tica_s' if ffi_type == 'SPOC' else 'tess_s'
+    # Should return empty dict if sector name does not match format
+    sector_name = 'invalid_s'
     sector_name += '0044-4-1'
     info = cutout._extract_sequence_information(sector_name)
     assert info == {}
@@ -135,18 +133,18 @@ def test_tess_footprint_cutout(cutout_size, caplog, ffi_type):
 def test_tess_footprint_cutout_multi_sequence(coordinates, cutout_size):
     """Test that a cube is created for each sequence when multiple are provided"""
     sequences = [1, 13]
-    cutout = TessFootprintCutout(coordinates, cutout_size, product='SPOC', sequence=sequences)
+    cutout = TessFootprintCutout(coordinates, cutout_size, sequence=sequences)
     cutout_tpfs = cutout.tpf_cutouts
     assert len(cutout_tpfs) == 2
 
     for tpf in cutout_tpfs:
-        check_output_tpf(tpf, 'SPOC', sequences)
+        check_output_tpf(tpf, sequences)
 
 
 def test_tess_footprint_cutout_all_sequences(coordinates, cutout_size):
     """Test that cubes are created for all sequences that intersect the cutout"""
     # Create cutouts for all possible sequences
-    cutout = TessFootprintCutout(coordinates, cutout_size, product='SPOC')
+    cutout = TessFootprintCutout(coordinates, cutout_size)
     cutout_tpfs = cutout.tpf_cutouts
     assert len(cutout_tpfs) >= 5
 
@@ -159,7 +157,7 @@ def test_tess_footprint_cutout_all_sequences(coordinates, cutout_size):
     # Assert non-empty results
     assert len(seq_list) == len(cutout_tpfs)
     for tpf in cutout_tpfs:
-        check_output_tpf(tpf, 'SPOC', sequences)
+        check_output_tpf(tpf, sequences)
 
 
 def test_tess_footprint_cutout_write_as_tpf(coordinates, cutout_size, tmpdir):
@@ -193,9 +191,12 @@ def test_tess_footprint_cutout_outside_coords(coordinates, cutout_size):
 
 def test_tess_footprint_cutout_invalid_product(coordinates, cutout_size):
     """Test that InvalidQueryError is raised if an invalid product is given"""
-    err = 'Product for TESS cube cutouts must be either "SPOC" or "TICA".'
+    err = 'Product for TESS cube cutouts must be "SPOC".'
     with pytest.raises(InvalidInputError, match=err):
         TessFootprintCutout(coordinates, cutout_size, product='invalid')
+
+    with pytest.raises(InvalidInputError, match=err):
+        TessFootprintCutout(coordinates, cutout_size, product='TICA')
 
 
 def test_cube_cut_from_footprint(coordinates, cutout_size, tmpdir):

astrocut/tica_cube_factory.py

@@ -4,10 +4,13 @@
 
 import numpy as np
 from astropy.io import fits
+from astropy.utils.decorators import deprecated
 
 from .cube_factory import CubeFactory
 
 
+@deprecated(since='1.1.0', message='The `TicaCubeFactory` class is deprecated and will be removed in a future version. ' 
+                                   'Use the `CubeFactory` class for creating image cubes from SPOC product files.')
 class TicaCubeFactory(CubeFactory):
     """
     Class for creating TICA image cubes. 
@@ -25,7 +28,6 @@ class TicaCubeFactory(CubeFactory):
         Note, this is the maximum amount of space to be used for the cube array only,
         so should not be set to the full amount of memory on the system.
     """
-
     def __init__(self, max_memory: int = 50):
         """ Setting up the class members."""
         super().__init__(max_memory=max_memory)