Autofix formatting from pre-commit.com hooks

Author: pre-commit-ci[bot]

slsim/Sources/SourceTypes/double_sersic.py

@@ -3,46 +3,52 @@
 from slsim.Util.param_util import ellipticity_slsim_to_lenstronomy
 from slsim.Util.param_util import surface_brightness_reff
 
+
 class DoubleSersic(SourceBase):
-    """class to manage source with double sersic light profile"""
+    """Class to manage source with double sersic light profile."""
+
     def __init__(self, source_dict):
         """
         :param source_dict: Source properties. May be a dictionary or an Astropy table.
-         This dict or table should contain atleast redshift, a magnitude in any band, 
+         This dict or table should contain atleast redshift, a magnitude in any band,
          sersic indices, sersic weight, angular sizes in arcsec, ellipticity.
          eg: {"z": 0.8, "mag_i": 22, "n_sersic_0": 1, "n_sersic_1": 4, "w0": 0.1,
-         "w1": 0.9, "angular_size0": 0.10, "angular_size1": 0.05, "e0_1": 0.002, 
-         "e0_2": 0.001, "e1_1": 0.0, "e1_2": 0.0}. One can provide magnitudes in 
+         "w1": 0.9, "angular_size0": 0.10, "angular_size1": 0.05, "e0_1": 0.002,
+         "e0_2": 0.001, "e1_1": 0.0, "e1_2": 0.0}. One can provide magnitudes in
          multiple bands.
         :type source_dict: dict or astropy.table.Table
         """
-        super().__init__(source_dict = source_dict)
+        super().__init__(source_dict=source_dict)
 
     @property
     def n_sersic(self):
         """Returns sersic indices of the source for double sersic profile."""
 
-        return (float(self.source_dict["n_sersic_0"]), 
-                float(self.source_dict["n_sersic_1"]))
-    
+        return (
+            float(self.source_dict["n_sersic_0"]),
+            float(self.source_dict["n_sersic_1"]),
+        )
+
     @property
     def sersicweight(self):
-        """Returns weight of the sersic components"""
+        """Returns weight of the sersic components."""
 
         return self.source_dict["w0"], self.source_dict["w1"]
 
     @property
     def angular_size(self):
-        """Returns angular size of the source for two component of
-          the sersic profile."""
+        """Returns angular size of the source for two component of the sersic
+        profile."""
 
-        return (float(self.source_dict["angular_size0"]),
-                 float(self.source_dict["angular_size1"]))
+        return (
+            float(self.source_dict["angular_size0"]),
+            float(self.source_dict["angular_size1"]),
+        )
 
     @property
     def ellipticity(self):
-        """Returns ellipticity components of source for the both component of 
-        the light profile. first two ellipticity components are associated with the 
+        """Returns ellipticity components of source for the both component of
+        the light profile. first two ellipticity components are associated with the
         first sersic component and last two are associated with the second sersic component.
         Defined as:
 
@@ -53,9 +59,13 @@ def ellipticity(self):
         with q being the minor-to-major axis ratio.
         """
 
-        return (float(self.source_dict["e0_1"]), float(self.source_dict["e0_2"]),
-                 float(self.source_dict["e1_1"]), float(self.source_dict["e1_2"]))
-    
+        return (
+            float(self.source_dict["e0_1"]),
+            float(self.source_dict["e0_2"]),
+            float(self.source_dict["e1_1"]),
+            float(self.source_dict["e1_2"]),
+        )
+
     def extended_source_magnitude(self, band):
         """Get the magnitude of the extended source in a specific band.
 
@@ -71,12 +81,12 @@ def extended_source_magnitude(self, band):
             band_string = "mag_" + band
         source_mag = self.source_dict[band_string]
         return source_mag
-    
+
     def kwargs_extended_source_light(self, reference_position, draw_area, band=None):
         """Provides dictionary of keywords for the source light model(s).
         Kewords used are in lenstronomy conventions.
 
-        :param reference_position: reference position. the source postion will be 
+        :param reference_position: reference position. the source postion will be
          defined relative to this position.
          Eg: np.array([0, 0])
         :param draw_area: The area of the test region from which we randomly draw a
@@ -136,11 +146,11 @@ def extended_source_light_model(self):
         :return: list of extented source model.
         """
         source_models_list = [
-                "SERSIC_ELLIPSE",
-                "SERSIC_ELLIPSE",
-            ]
+            "SERSIC_ELLIPSE",
+            "SERSIC_ELLIPSE",
+        ]
         return source_models_list
-    
+
     def surface_brightness_reff(self, band=None):
         """Calculate average surface brightness within half light radius.
 
@@ -150,8 +160,11 @@ def surface_brightness_reff(self, band=None):
         """
         angularsize = np.mean(self.angular_size)
         # reference_position and draw_area do not matter, they are dummy input here.
-        kwargs_source = self.kwargs_extended_source_light(reference_position=[0, 0],
-                                                           draw_area=4*np.pi, band=band)
-        return surface_brightness_reff(angular_size=angularsize, 
-                        source_model_list=self.extended_source_light_model(),
-                kwargs_extended_source=kwargs_source)
+        kwargs_source = self.kwargs_extended_source_light(
+            reference_position=[0, 0], draw_area=4 * np.pi, band=band
+        )
+        return surface_brightness_reff(
+            angular_size=angularsize,
+            source_model_list=self.extended_source_light_model(),
+            kwargs_extended_source=kwargs_source,
+        )

slsim/Sources/SourceTypes/extended_source.py

@@ -4,21 +4,22 @@
 
 _SUPPORTED_EXTENDED_SOURCES = ["single_sersic", "double_sersic", "interpolated"]
 
+
 class ExtendedSource(object):
-    """Class to manage a single extended source"""
-    def __init__(self, source_dict,
-                  cosmo=None, **kwargs):
+    """Class to manage a single extended source."""
+
+    def __init__(self, source_dict, cosmo=None, **kwargs):
         """
         :param source_dict: Source properties. May be a dictionary or an Astropy table.
          For a detailed description of this dictionary, please see the documentation for
          the SingleSersic, DoubleSersic, and Interpolated classes.
         :type source_dict: dict or astropy.table.Table
         :param extendedsource_type: keyword for specifying light profile model.
-        :type extendedsource_type: str. supported types are "single_sersic", 
+        :type extendedsource_type: str. supported types are "single_sersic",
          "double_sersic", "interpolated".
         :param cosmo: astropy.cosmology instance
         :param kwargs: dictionary of keyword arguments for a extended source.
-         eg: kwargs = {"extendedsource_type": "single_sersic"}. Other supported 
+         eg: kwargs = {"extendedsource_type": "single_sersic"}. Other supported
          types are "single_sersic", "double_sersic", "interpolated".
         """
         self.extendedsource_type = kwargs["extendedsource_type"]
@@ -33,19 +34,19 @@ def __init__(self, source_dict,
                 "Extended source type %s not supported. Chose among %s."
                 % (self.extendedsource_type, _SUPPORTED_EXTENDED_SOURCES)
             )
-    
+
     @property
     def redshift(self):
         """Returns source redshift."""
 
         return self._source.redshift
-    
+
     @property
     def angular_size(self):
         """Returns angular size of the source."""
 
         return self._source.angular_size
-    
+
     @property
     def ellipticity(self):
         """Returns ellipticity components of source.
@@ -57,9 +58,9 @@ def ellipticity(self):
 
         with q being the minor-to-major axis ratio.
         """
-        
+
         return self._source.ellipticity
-    
+
     @property
     def n_sersic(self):
         """Returns sersic indices of the source profile."""
@@ -68,48 +69,49 @@ def n_sersic(self):
 
     @property
     def sersicweight(self):
-        """Returns weight of the sersic components"""
+        """Returns weight of the sersic components."""
 
         return self._source.sersicweight
-    
+
     @property
     def image_redshift(self):
-        """Returns redshift of a given image"""
-        
+        """Returns redshift of a given image."""
+
         return self._source.image_redshift
-    
+
     @property
     def image(self):
-        """Returns image of a given extended source"""
-        
+        """Returns image of a given extended source."""
+
         return self._source.image
 
     @property
     def phi(self):
-        """Returns position angle of a given image in arcsec"""
+        """Returns position angle of a given image in arcsec."""
 
         return self._source.phi
-    
+
     @property
     def pixel_scale(self):
-        """Returns pixel scale of a given image"""
+        """Returns pixel scale of a given image."""
 
         return self._source.pixel_scale
-    
+
     def extended_source_position(self, reference_postion, draw_area):
         """Extended source position. If a center has already been provided (and
-        stored in self._center_source during initialization of _source), then it is simply
-        returned. Otherwise, a source position is drawn uniformly within the
-        circle of the test area centered on the deflector position. see: _source.
+        stored in self._center_source during initialization of _source), then
+        it is simply returned. Otherwise, a source position is drawn uniformly
+        within the circle of the test area centered on the deflector position.
+        see: _source.
 
-        :param reference_position: reference position. the source postion will be 
+        :param reference_position: reference position. the source postion will be
          defined relative to this position.
          Eg: np.array([0, 0])
         :param draw_area: The area of the test region from which we randomly draw a source
             position. Eg: 4*pi.
         :return: [x_pos, y_pos]
         """
-        
+
         return self._source.extended_source_position(reference_postion, draw_area)
 
     def extended_source_magnitude(self, band):
@@ -122,29 +124,31 @@ def extended_source_magnitude(self, band):
         """
 
         return self._source.extended_source_magnitude(band=band)
-    
+
     def kwargs_extended_source_light(self, reference_position, draw_area, band=None):
         """Provides dictionary of keywords for the source light model(s).
         Kewords used are in lenstronomy conventions.
 
-        :param reference_position: reference position. the source postion will be 
+        :param reference_position: reference position. the source postion will be
          defined relative to this position.
          Eg: np.array([0, 0])
         :param draw_area: The area of the test region from which we randomly draw a
          source position. Eg: 4*pi.
         :param band: Imaging band
         :return: dictionary of keywords for the source light model(s)
         """
-        
-        return self._source.kwargs_extended_source_light(reference_position, draw_area, band)
-    
+
+        return self._source.kwargs_extended_source_light(
+            reference_position, draw_area, band
+        )
+
     def extended_source_light_model(self):
         """Provides a list of source models.
 
         :return: list of extented source model.
         """
         return self._source.extended_source_light_model()
-    
+
     def surface_brightness_reff(self, band=None):
         """Calculate average surface brightness within half light radius.
 
@@ -153,4 +157,4 @@ def surface_brightness_reff(self, band=None):
             [mag/arcsec^2]
         """
 
-        return self._source.surface_brightness_reff(band=band)
+        return self._source.surface_brightness_reff(band=band)

slsim/Sources/SourceTypes/general_lightcurve.py

@@ -1,18 +1,17 @@
 from slsim.Sources.SourceVariability.variability import Variability
 from slsim.Sources.SourceTypes.source_base import SourceBase
 
+
 class GeneralLightCurve(SourceBase):
-    """A class to manage a source with given lightcurve"""
-    def __init__(self,
-        source_dict,
-        **kwargs
-        ):
+    """A class to manage a source with given lightcurve."""
+
+    def __init__(self, source_dict, **kwargs):
         """
         :param source_dict: Source properties. May be a dictionary or an Astropy table.
-         This table or dict should contain atleast redshift of a supernova, offset from 
-         the host if host galaxy is available, and lightcurve in a desired band. 
-         eg: data={"z": 0.8, "MJD": 
-         np.array([1,2,3,4,5,6,7,8,9]), 
+         This table or dict should contain atleast redshift of a supernova, offset from
+         the host if host galaxy is available, and lightcurve in a desired band.
+         eg: data={"z": 0.8, "MJD":
+         np.array([1,2,3,4,5,6,7,8,9]),
          "ps_mag_i": np.array([15, 16, 17, 18, 19, 20, 21, 22, 23]), "ra_off": 0.001,
            "dec_off": 0.002}
         :type source_dict: dict or astropy.table.Table
@@ -22,10 +21,11 @@ def __init__(self,
             input for the Variability class.
             :type variability_model: str
         """
-        
-        super().__init__(source_dict = source_dict)
+
+        super().__init__(source_dict=source_dict)
         # These are the keywords that kwargs dict should contain
         self.variability_model = kwargs.get("variability_model")
+
     def point_source_magnitude(self, band, image_observation_times=None):
         """Get the magnitude of the point source in a specific band.
 
@@ -39,18 +39,21 @@ def point_source_magnitude(self, band, image_observation_times=None):
 
         column_names = self.source_dict.colnames
         if "ps_mag_" + band not in column_names:
-            raise ValueError("%s band magnitudes are missing in the source dictionary." % band)
+            raise ValueError(
+                "%s band magnitudes are missing in the source dictionary." % band
+            )
         else:
             band_string = "ps_mag_" + band
-            kwargs_variab_band = {"MJD": self.source_dict["MJD"], 
-                                band_string: self.source_dict[band_string]}
+            kwargs_variab_band = {
+                "MJD": self.source_dict["MJD"],
+                band_string: self.source_dict[band_string],
+            }
             self.variability_class = Variability(
-                    self.variability_model, **kwargs_variab_band
-                )
+                self.variability_model, **kwargs_variab_band
+            )
         if image_observation_times is not None:
-                variable_mag = self.variability_class.variability_at_time(
-                    image_observation_times
-                )
-                return variable_mag
+            variable_mag = self.variability_class.variability_at_time(
+                image_observation_times
+            )
+            return variable_mag
         return kwargs_variab_band[band_string]
-