Updating style checks using ruff.

src/stcal/jump/jump.py

@@ -1,3 +1,6 @@
+#  jump.py - detect cosmic ray jumps and their side effects like
+#            snowballs and showers.
+
 import logging
 import multiprocessing
 import time
@@ -19,7 +22,8 @@
 
 def detect_jumps_data(jump_data):
     """
-    This is the high-level controlling routine for the jump detection process.
+    Detect jumps and their side effects, such as showers and snowballs.
+
     It loads and sets the various input data and parameters needed by each of
     the individual detection methods and then calls the detection methods in
     turn.
@@ -125,7 +129,7 @@ def detect_jumps_data(jump_data):
 
 def twopoint_diff_multi(jump_data, twopt_params, data, gdq, readnoise_2d, n_slices):
     """
-    Implements multiprocessing for jump detection.
+    Split data for jump detection multiprocessing.
     
     Parameters
     ----------
@@ -322,7 +326,7 @@ def slice_data(twopt_params, data, gdq, readnoise_2d, n_slices):
 
 def setup_pdq(jump_data):
     """
-    Prepares the pixel DQ array for procesing, removing invalid data.
+    Prepare the pixel DQ array for procesing, removing invalid data.
 
     Paramter
     --------
@@ -343,8 +347,7 @@ def setup_pdq(jump_data):
 
 def flag_large_events(gdq, jump_flag, sat_flag, jump_data):
     """
-    This routine controls the creation of expanded regions that are flagged as
-    jumps.
+    Control the creation of expanded regions that are flagged as jumps.
 
     These events are called snowballs for the NIR. While they are most commonly
     circular, there are elliptical ones. This routine does not handle the
@@ -424,7 +427,7 @@ def flag_large_events(gdq, jump_flag, sat_flag, jump_data):
 
 def extend_saturation(cube, grp, sat_ellipses, jump_data, persist_jumps):
     """
-    Extend the saturated ellipses that are larger than the min_sat_radius
+    Extend the saturated ellipses that are larger than the min_sat_radius.
     
     Parameter
     ---------
@@ -702,9 +705,10 @@ def point_inside_ellipse(point, ellipse):
 
 def near_edge(jump, low_threshold, high_threshold):
     """
-    This routing tests whether the center of a jump is close to the edge of
-    the detector. Jumps that are within the threshold will not require a
-    saturated core since this may be off the detector
+    Test whether the center of a jump is close to the edge of the detector.
+
+    Jumps that are within the threshold will not require a saturated core
+    since this may be off the detector
 
     Parameter
     ---------
@@ -734,7 +738,7 @@ def near_edge(jump, low_threshold, high_threshold):
 def find_faint_extended(
         indata, ingdq, pdq, readnoise_2d, jump_data, min_diffs_for_shower=10):
     """
-    Flagging showers.
+    Flag groups based on showers detected.
 
     Parameters
     ----------
@@ -846,7 +850,7 @@ def find_faint_extended(
 
 def max_flux_showers(jump_data, nints, indata, ingdq, gdq):
     """
-    Ensure that flagging showers didn't change final fluxes by more than the allowed amount
+    Ensure that flagging showers didn't change final fluxes by more than allowed.
 
     Parameter
     ---------
@@ -935,7 +939,7 @@ def count_dnu_groups(gdq, jump_data):
 
 def process_ellipses(ellipses, image, expand_by_ratio, expansion, jump_data):
     """
-    Draw ellipses onto an image
+    Draw ellipses onto an image.
 
     Parameters
     ----------
@@ -971,12 +975,13 @@ def process_ellipses(ellipses, image, expand_by_ratio, expansion, jump_data):
 
 
 def compute_axes(expand_by_ratio, ellipse, expansion, jump_data):
-    '''
-    Expand the ellipse by the expansion factor. The number of pixels added to
-    both axes is the number of pixels added to the minor axis. This prevents
-    very large flagged ellipses with high axis ratio ellipses. The major and
-    minor axis are not always the same index.  Therefore, we have to test to
-    find which is actually the minor axis.
+    """
+    Expand the ellipse by the expansion factor.
+
+    The number of pixels added to both axes is the number of pixels added
+    to the minor axis. This prevents very large flagged ellipses with high
+    axis ratio ellipses. The major and minor axis are not always the same
+    index.  Therefore, we have to test to find which is actually the minor axis.
 
     Parameters
     ----------
@@ -996,7 +1001,7 @@ def compute_axes(expand_by_ratio, ellipse, expansion, jump_data):
     ______
     axes : tuple
         Expanded and rounded ellipse axes.
-    '''
+    """
     if expand_by_ratio:
         if ellipse[1][1] < ellipse[1][0]:
             axis1 = ellipse[1][0] + (expansion - 1.0) * ellipse[1][1]
@@ -1080,7 +1085,7 @@ def get_bigcontours(ratio, intg, grp, gdq, pdq, jump_data, ring_2D_kernel):
 
 def diff_meddiff_int(intg, median_diffs, sigma, first_diffs_masked):
     """
-    Computes the SNR ratio of each difference.
+    Compute the SNR ratio of each difference.
 
     Parameters
     ----------
@@ -1194,7 +1199,7 @@ def nan_invalid_data(data, gdq, jump_data):
 
 def find_first_good_group(int_gdq, do_not_use):
     """
-    Find first good group
+    Find first good group.
 
     Parameter
     ---------
@@ -1224,9 +1229,7 @@ def find_first_good_group(int_gdq, do_not_use):
 
 def calc_num_slices(n_rows, max_cores, max_available):
     """
-    Compute the number of data slices needed for multiprocessesing, based
-    on requested number of processes, available number of processes, and
-    the number of rows (the data is sliced by row).
+    Compute the number of data slices needed for multiprocessesing.
 
     Parameter
     ---------

src/stcal/jump/jump_class.py

@@ -2,10 +2,12 @@
 DELIM = "-" * 80
 
 class JumpData:
-    def __init__(
-        self, jump_model=None, gain2d=None, rnoise2d=None, dqflags=None
-    ):
+    """Contains data needed for detecting jumps."""
+
+    def __init__(self, jump_model=None, gain2d=None, rnoise2d=None, dqflags=None):
         """
+        Initialize JumpData instance.
+
         jump_model : model
             Input data model, assumed to be of type RampModel.
 
@@ -196,7 +198,7 @@ def __init__(
 
     def init_arrays_from_model(self, jump_model):
         """
-        Sets arrays from a data model.
+        Set arrays from a data model.
 
         jump_model : datamodel
             A datamodel with certain expected parameters.
@@ -207,7 +209,7 @@ def init_arrays_from_model(self, jump_model):
 
     def init_arrays_from_arrays(self, data, gdq, pdq):
         """
-        Sets arrays from a numpy arrays.
+        Set arrays from a numpy arrays.
 
         Parameters
         ----------
@@ -226,7 +228,7 @@ def init_arrays_from_arrays(self, data, gdq, pdq):
 
     def set_detection_settings(self, rej, _3grp, _4grp, mx, mn, _4flag):
         """
-        Set class instance detection settings
+        Set class instance detection settings.
 
         Parameters
         ----------
@@ -402,6 +404,7 @@ def set_sigma_clipping_info(self, mingrps, minsig, useints):
     # Print methods, primarily used for debugging.
 
     def print_jump_data(self, fd=None):
+        """Print jump_data information."""
         self.print_jump_data_arrays(fd=fd)
         self.print_jump_data_options(fd=fd)
         self.print_jump_data_dqflags(fd=fd)
@@ -411,13 +414,15 @@ def print_jump_data(self, fd=None):
         self.print_jump_data_internal_state(fd=fd)
 
     def print_jump_data_arrays(self, pix_list=None, fd=None):
+        """Print jump_data arrays."""
         if fd is None:
             print(self.get_jump_data_arrays())
         else:
             print(self.get_jump_data_arrays(), file=fd)
 
 
     def get_jump_data_arrays(self):
+        """Return string of jump_data information."""
         oline = f"{DELIM}\n"
         oline += "JumpData Arrays\n"
         oline += f"Data shape = {self.data.shape}\n"
@@ -433,12 +438,14 @@ def get_jump_data_arrays(self):
         return oline
 
     def print_jump_data_options(self, fd=None):
+        """Print jump_data options."""
         if fd is None:
             print(self.get_jump_data_options())
         else:
             print(self.get_jump_data_options(), file=fd)
 
     def get_jump_data_options(self):
+        """Return string of jump_data option."""
         oline = f"{DELIM}\n"
         oline += f"JumpData Options\n"
         oline += f"nframes = {self.nframes}\n"
@@ -463,12 +470,14 @@ def get_jump_data_options(self):
         return oline
 
     def print_jump_data_dqflags(self, fd=None):
+        """Print string of jump_data dqflags."""
         if fd is None:
             print(self.get_jump_data_dqflags())
         else:
             print(self.get_jump_data_dqflags(), file=fd)
 
     def get_jump_data_dqflags(self):
+        """Return string of jump_data dqflags."""
         oline = f"{DELIM}\n"
         oline += "DQ Flags\n"
         oline += f"{INDENT}fl_good = {self.fl_good}\n"
@@ -481,12 +490,14 @@ def get_jump_data_dqflags(self):
         return oline
 
     def print_jump_data_snowball(self, fd=None):
+        """Print string of jump_data snowball data."""
         if fd is None:
             print(self.get_jump_data_snowball())
         else:
             print(self.get_jump_data_snowball(), file=fd)
 
     def get_jump_data_snowball(self):
+        """Return string of jump_data snowball data."""
         oline = f"{DELIM}\n"
         oline += "Snowball Information\n"
         oline += f"expand_large_events = {self.expand_large_events}\n"
@@ -502,12 +513,14 @@ def get_jump_data_snowball(self):
         return oline
 
     def print_jump_data_shower(self, fd=None):
+        """Print string of jump_data shower data."""
         if fd is None:
             print(self.get_jump_data_shower())
         else:
             print(self.get_jump_data_shower(), file=fd)
 
     def get_jump_data_shower(self):
+        """Return string of jump_data shower data."""
         oline = f"{DELIM}\n"
         oline += "Shower Information\n"
         oline += f"find_showers = {self.find_showers}\n"
@@ -522,12 +535,14 @@ def get_jump_data_shower(self):
         return oline
 
     def print_jump_data_sigma_clipping(self, fd=None):
+        """Print string of jump_data sigma clipping data."""
         if fd is None:
             print(self.get_jump_data_sigma_clipping())
         else:
             print(self.get_jump_data_sigma_clipping(), file=fd)
 
     def get_jump_data_sigma_clipping(self):
+        """Return string of jump_data sigma clipping data."""
         oline = f"{DELIM}\n"
         oline += "Sigma Clipping\n"
         oline += f"minimum_groups = {self.minimum_groups}\n"
@@ -537,12 +552,14 @@ def get_jump_data_sigma_clipping(self):
         return oline
 
     def print_jump_data_internal_state(self, fd=None):
+        """Print string of jump_data internal state."""
         if fd is None:
             print(self.get_jump_data_internal_state())
         else:
             print(self.get_jump_data_internal_state(), file=fd)
 
     def get_jump_data_internal_state(self):
+        """Return string of jump_data internal state."""
         oline = f"{DELIM}\n"
         oline += "Internal State\n"
         oline += f"grps_masked_after_shower = {self.grps_masked_after_shower}\n"

src/stcal/jump/twopoint_difference.py

@@ -11,6 +11,8 @@
 
 def find_crs(dataa, group_dq, read_noise, twopt_p):
     """
+    Detect jump due to cosmic rays using the two point difference method.
+
     An interface between the detect_jumps_data function and the
     find_crs_old function using the TwoPointParams class that makes
     adding and removing parameters when using the two point
@@ -99,11 +101,12 @@ def find_crs_old(
     min_diffs_single_pass=10,
 ):
     """
-    Find CRs/Jumps in each integration within the input data array. The input
-    data array is assumed to be in units of electrons, i.e. already multiplied
-    by the gain. We also assume that the read noise is in units of electrons.
-    We also assume that there are at least three groups in the integrations.
-    This was checked by jump_step before this routine is called.
+    Find CRs/Jumps in each integration within the input data array.
+
+    The input data array is assumed to be in units of electrons, i.e. already
+    multiplied by the gain. We also assume that the read noise is in units of
+    electrons.  We also assume that there are at least three groups in the
+    integrations. This was checked by jump_step before this routine is called.
 
     Parameters
     ----------
@@ -183,6 +186,7 @@ def find_crs_old(
     min_diffs_single_pass: integer
         The minimum number of groups to switch from the iterative flagging of
         cosmic rays to just finding all the outliers at once.
+
     Returns
     -------
     gdq : int, 4D array
@@ -526,6 +530,7 @@ def calc_med_first_diffs(in_first_diffs):
     those three groups will be returned without any clipping. Finally, if
     there are two usable groups, the group with the smallest absolute
     difference will be returned.
+
     Parameters
     ----------
     in_first_diffs : array, float

src/stcal/jump/twopoint_difference_class.py

@@ -1,5 +1,18 @@
 class TwoPointParams:
+    """Contains data needed for computing two point difference."""
+
     def __init__(self, jump_data=None, copy_arrs=False):
+        """
+        Initialize TwoPointParams instance.
+
+        Parameters
+        ----------
+        jump_data : JumpData
+            Class containing parameters and methods to detect jumps.
+
+        copy_arrs : bool
+            Should the arrays be copied.
+        """
         if jump_data is not None:
             self.normal_rej_thresh = jump_data.rejection_thresh
 
@@ -58,6 +71,7 @@ def __init__(self, jump_data=None, copy_arrs=False):
         self.copy_arrs = copy_arrs
 
     def __repr__(self):
+        """Create __repr__ string."""
         delim = "-" * 60
         ostr = f"{delim}\n"
         ostr += f"normal_rej_thresh = {self.normal_rej_thresh}\n"