Renamed funcitions (#158)

.readthedocs.yml

@@ -1,16 +1,26 @@
 version: 2
+
 build:
-  os: ubuntu-20.04
+  os: ubuntu-22.04
   tools:
-    python: "3.9"
-  apt_packages:
-    - graphviz
+    python: "mambaforge-4.10"
+  jobs:
+    post_checkout:
+      - git fetch --unshallow || true
+    pre_install:
+      - git update-index --assume-unchanged .rtd-environment.yml docs/conf.py
+
+conda:
+  environment: .rtd-environment.yml
 
 sphinx:
   builder: html
   configuration: docs/conf.py
   fail_on_warning: false
 
+formats:
+  - htmlzip
+
 python:
    install:
      - method: pip

.rtd-environment.yml

@@ -0,0 +1,7 @@
+name: rtd_sunkit_image
+channels:
+  - conda-forge
+dependencies:
+  - python=3.10
+  - pip
+  - graphviz!=2.42.*,!=2.43.*

CHANGELOG.rst

@@ -16,6 +16,14 @@ Backwards Incompatible Changes
   - ``find_best_match_location``
   - ``calculate_shift`` (`#100 <https://github.com/sunpy/sunkit-image/pull/100>`__)
 
+- The following helper functions in `sunkit_image.radial` have been removed, with no replacement.
+  This is because they are designed to be internal helper functions.
+  If you need to use them in your own code create a copy of the functions from the ``sunkit-image`` source code.
+
+  - ``fit_polynomial_to_log_radial_intensity``
+  - ``calculate_fit_radial_intensity``
+  - ``normalize_fit_radial_intensity``
+
 - Made the following functions in `sunkit_image.trace` private:
 
   1. ``curvature_radius`` (renamed to ``_curvature_radius``)

docs/conf.py

@@ -36,7 +36,6 @@
     os.environ["LC_ALL"] = "C"
     os.environ["HIDE_PARFIVE_PROGESS"] = "True"
 
-
 project = "sunkit_image"
 author = "The SunPy Community"
 copyright = f"{datetime.datetime.now().year}, {author}"  # NOQA: A001

sunkit_image/coalignment.py

@@ -15,8 +15,6 @@
 from sunpy.physics.differential_rotation import solar_rotate_coordinate
 from sunpy.util.exceptions import SunpyUserWarning
 
-__author__ = "J. Ireland"
-
 __all__ = [
     "match_template_to_layer",
     "apply_shifts",

sunkit_image/radial.py

@@ -10,17 +10,14 @@
 from sunkit_image.utils import bin_edge_summary, equally_spaced_bins, find_pixel_radii, get_radial_intensity_summary
 
 __all__ = [
-    "fit_polynomial_to_log_radial_intensity",
-    "calculate_fit_radial_intensity",
-    "normalize_fit_radial_intensity",
+    "fnrgf",
     "intensity_enhance",
-    "nrgf",
     "set_attenuation_coefficients",
-    "fnrgf",
+    "nrgf",
 ]
 
 
-def fit_polynomial_to_log_radial_intensity(radii, intensity, degree):
+def _fit_polynomial_to_log_radial_intensity(radii, intensity, degree):
     """
     Fits a polynomial of  a given degree to the log of the radial intensity.
 
@@ -43,7 +40,7 @@ def fit_polynomial_to_log_radial_intensity(radii, intensity, degree):
     return np.polyfit(radii.to(u.R_sun).value, np.log(intensity), degree)
 
 
-def calculate_fit_radial_intensity(radii, polynomial):
+def _calculate_fit_radial_intensity(radii, polynomial):
     """
     Calculates the fit value of the radial intensity at the values ``radii``.
 
@@ -68,7 +65,7 @@ def calculate_fit_radial_intensity(radii, polynomial):
     return np.exp(np.poly1d(polynomial)(radii.to(u.R_sun).value))
 
 
-def normalize_fit_radial_intensity(radii, polynomial, normalization_radius):
+def _normalize_fit_radial_intensity(radii, polynomial, normalization_radius):
     """
     Normalizes the fitted radial intensity to the value at the normalization
     radius.
@@ -93,7 +90,7 @@ def normalize_fit_radial_intensity(radii, polynomial, normalization_radius):
         An array with the same shape as radii which expresses the fitted
         intensity value normalized to its value at the normalization radius.
     """
-    return calculate_fit_radial_intensity(radii, polynomial) / calculate_fit_radial_intensity(
+    return _calculate_fit_radial_intensity(radii, polynomial) / _calculate_fit_radial_intensity(
         normalization_radius,
         polynomial,
     )
@@ -192,14 +189,14 @@ def intensity_enhance(
 
     # Fits a polynomial function to the natural logarithm of an estimate of
     # the intensity as a function of radius.
-    polynomial = fit_polynomial_to_log_radial_intensity(
+    polynomial = _fit_polynomial_to_log_radial_intensity(
         radial_bin_summary[fit_here],
         radial_intensity[fit_here],
         degree,
     )
 
     # Calculate the enhancement
-    enhancement = 1 / normalize_fit_radial_intensity(map_r, polynomial, normalization_radius)
+    enhancement = 1 / _normalize_fit_radial_intensity(map_r, polynomial, normalization_radius)
     enhancement[map_r < normalization_radius] = 1
 
     # Return a map with the intensity enhanced above the normalization radius
@@ -374,11 +371,8 @@ def fnrgf(
     order,
     attenuation_coefficients,
     ratio_mix=[15, 1],
-    scale=None,
     intensity_summary=np.nanmean,
-    intensity_summary_kwargs={},
     width_function=np.std,
-    width_function_kwargs={},
     application_radius=1 * u.R_sun,
     number_angular_segments=130,
 ):
@@ -417,20 +411,12 @@ def fnrgf(
         A one dimensional array of shape ``[2, 1]`` with values equal to ``[K1, K2]``.
         The ratio in which the original image and filtered image are mixed.
         Defaults to ``[15, 1]``.
-    scale : `None` or `astropy.units.Quantity`, optional
-        The radius of the Sun expressed in map units. For example, in typical
-        helioprojective Cartesian maps the solar radius is expressed in units
-        of arcseconds. If `None` (the default), then the map scale is used.
     intensity_summary :`function`, optional
         A function that returns a summary statistic of the radial intensity.
         Default is `numpy.nanmean`.
-    intensity_summary_kwargs : `None`, `~dict`
-        Keywords applicable to the summary function.
     width_function : `function`
         A function that returns a summary statistic of the distribution of intensity, at a given radius.
         Defaults to `numpy.std`.
-    width_function_kwargs : `function`
-        Keywords applicable to the width function.
     application_radius : `astropy.units.Quantity`
         The FNRGF is applied to emission at radii above the application_radius.
         Defaults to 1 solar radii.
@@ -558,17 +544,17 @@ def fnrgf(
         phi_matrix = angles[annulus].reshape((1, angles[annulus].shape[0]))
         angles_of_pixel = K_matrix * phi_matrix
 
-        # Get the approxiamted value of mean
+        # Get the approximated value of mean
         mean_approximated = np.matmul(fourier_coefficients_a_k, np.cos(angles_of_pixel))
         mean_approximated += np.matmul(fourier_coefficients_b_k, np.sin(angles_of_pixel))
         mean_approximated += fourier_coefficient_a_0 / 2
 
-        # Get the approxiamted value of standard deviation
+        # Get the approximated value of standard deviation
         std_approximated = np.matmul(fourier_coefficients_c_k, np.cos(angles_of_pixel))
         std_approximated += np.matmul(fourier_coefficients_d_k, np.sin(angles_of_pixel))
         std_approximated += fourier_coefficient_c_0 / 2
 
-        # Normailize the data
+        # Normalize the data
         # Refer equation (7) in the paper
         std_approximated = np.where(std_approximated == 0.00, 1, std_approximated)
         data[annulus] = np.ravel((smap.data[annulus] - mean_approximated) / std_approximated)

sunkit_image/tests/test_radial.py

@@ -225,27 +225,27 @@ def test_fit_polynomial_to_log_radial_intensity():
     degree = 1
     expected = np.polyfit(radii.to(u.R_sun).value, np.log(intensity), degree)
 
-    assert np.allclose(rad.fit_polynomial_to_log_radial_intensity(radii, intensity, degree), expected)
+    assert np.allclose(rad._fit_polynomial_to_log_radial_intensity(radii, intensity, degree), expected)
 
 
 def test_calculate_fit_radial_intensity():
     polynomial = np.asarray([1, 2, 3])
     radii = (0.001, 0.002) * u.R_sun
     expected = np.exp(np.poly1d(polynomial)(radii.to(u.R_sun).value))
 
-    assert np.allclose(rad.calculate_fit_radial_intensity(radii, polynomial), expected)
+    assert np.allclose(rad._calculate_fit_radial_intensity(radii, polynomial), expected)
 
 
 def test_normalize_fit_radial_intensity():
     polynomial = np.asarray([1, 2, 3])
     radii = (0.001, 0.002) * u.R_sun
     normalization_radii = (0.003, 0.004) * u.R_sun
-    expected = rad.calculate_fit_radial_intensity(radii, polynomial) / rad.calculate_fit_radial_intensity(
+    expected = rad._calculate_fit_radial_intensity(radii, polynomial) / rad._calculate_fit_radial_intensity(
         normalization_radii,
         polynomial,
     )
 
-    assert np.allclose(rad.normalize_fit_radial_intensity(radii, polynomial, normalization_radii), expected)
+    assert np.allclose(rad._normalize_fit_radial_intensity(radii, polynomial, normalization_radii), expected)
 
 
 @skip_windows
@@ -268,13 +268,13 @@ def test_intensity_enhance(map_test1):
         radial_bin_summary.to(u.R_sun).value <= fit_range[1].to(u.R_sun).value,
     )
 
-    polynomial = rad.fit_polynomial_to_log_radial_intensity(
+    polynomial = rad._fit_polynomial_to_log_radial_intensity(
         radial_bin_summary[fit_here],
         radial_intensity[fit_here],
         degree,
     )
 
-    enhancement = 1 / rad.normalize_fit_radial_intensity(map_r, polynomial, normalization_radius)
+    enhancement = 1 / rad._normalize_fit_radial_intensity(map_r, polynomial, normalization_radius)
     enhancement[map_r < normalization_radius] = 1
 
     with pytest.raises(ValueError, match="The fit range must be strictly increasing."):

sunkit_image/utils/decorators.py

@@ -1,5 +1,6 @@
 import inspect
 from typing import Union, Callable
+from functools import wraps
 
 import numpy as np
 from sunpy.map import GenericMap, Map
@@ -31,6 +32,7 @@ def decorate(f: Callable) -> Callable:
         if arg_name not in sig.parameters:
             raise RuntimeError(f"Could not find '{arg_name}' in function signature")
 
+        @wraps(f)
         def inner(*args, **kwargs) -> Union[np.ndarray, GenericMap]:
             sig_bound = sig.bind(*args, **kwargs)
             map_arg = sig_bound.arguments[arg_name]