exovetter 0.0.6__py3-none-any.whl → 0.0.7__py3-none-any.whl

exovetter/utils.py

@@ -2,12 +2,19 @@
 
 import sys
 import warnings
-
+from exovetter import lightkurve_utils
+from exovetter import utils
+from exovetter import const as exo_const
+import astropy.units as u
+from exovetter import vetters as vet
+from matplotlib.backends.backend_pdf import PdfPages
+import matplotlib.pyplot as plt
 import numpy as np
+import os
 
 __all__ = ['sine', 'estimate_scatter', 'mark_transit_cadences', 'median_detrend', 
            'plateau', 'set_median_flux_to_zero', 'set_median_flux_to_one', 'sigmaClip', 
-           'get_mast_tce', 'WqedLSF', 'compute_phases', 'first_epoch']
+           'get_mast_tce', 'WqedLSF', 'compute_phases', 'first_epoch', 'run_all']
 
 def sine(x, order, period=1):
     """Sine function for SWEET vetter."""
@@ -653,3 +660,164 @@ def first_epoch(epoch, period, lc):
         first_epoch = epoch + N*period
 
     return first_epoch
+
+def run_all(tce, lc, tpf=None, vetters=None, remove_metrics=None, plot=False, plot_dir=None):
+    """Run a set of vetters on a tce and lc, returning a dictionary of all metrics collected
+    
+    Parameters
+    ----------
+    tce : tce object
+        tce object is a dictionary that contains information about the tce
+        to vet, like period, epoch, duration, depth
+
+    lc : lightkurve object
+        lightkurve object with the time and flux to use for vetting.
+
+    tpf : obj
+        ``lightkurve`` target pixel file object with pixels in column lc_name
+
+    vetters : list
+        list of vetter objects to run on, ie [vet.ModShift(), vet.OddEven(dur_frac=0.75)]
+        Defaults to all vetters
+    
+    remove_metrics : list
+        metrics to not store, defaults to removing plotting values
+
+    plot : bool
+        Option to return a pdf of the vetting diagnostic plots, defaults to False
+
+    plot_dir : str
+        Path to store diagnostic pdfs in, defaults to current working directory
+
+    Returns
+    -------
+    results_dict : dictionary
+        Dictionary of the kept vetting metrics
+    """
+    
+    # Set initial parameters
+    if not vetters:
+        vetters = [vet.VizTransits(), vet.ModShift(), vet.Lpp(), vet.OddEven(), vet.TransitPhaseCoverage(), vet.Sweet(), vet.LeoTransitEvents(), vet.Centroid()]
+
+    if not remove_metrics:
+        remove_metrics = ['plot_data']
+
+    if not plot_dir:
+        plot_dir = os.getcwd()+'/'
+
+    if not tpf:
+        if any(vetter.__class__.__name__ == 'Centroid' for vetter in vetters):
+            raise Exception("TPF file required while running centroid")
+
+    # Run all listed vetters
+    results_list = []
+
+    if not plot:
+        for vetter in vetters:
+            if vetter.__class__.__name__ != 'Centroid':
+                vetter_results = vetter.run(tce, lc, plot=False) # dictionary returned from each vetter
+                results_list.append(vetter_results)
+            else:
+                vetter_results = vetter.run(tce, tpf, plot=False) # centroid uses tpf rather than lc
+                results_list.append(vetter_results)
+
+    else:
+        plot_name = lc.LABEL
+
+        diagnostic_plot = PdfPages(plot_dir+plot_name+'.pdf') # initialize a pdf to save each figure into
+        plot_figures = []
+        
+        # Manually run viz transits with an extra mark cadences plot
+        cadences_plot = mark_cadences_plot(lc, tce)
+        diagnostic_plot.savefig(cadences_plot)
+
+        for vetter in vetters:
+            if vetter.__class__.__name__ not in ['VizTransits', 'Centroid', 'LeoTransitEvents']: # viz_transits and Centroid generate more than one figures so handle later
+                vetter_results = vetter.run(tce, lc, plot=True) # dictionary returned from each vetter
+                plot_figures.append(plt.gcf())
+                plt.close() # Make them not show up if running in a notebook
+                results_list.append(vetter_results)
+
+            if vetter.__class__.__name__ == 'Centroid': # centroid produces 2 plots, the second of which is the most useful so just collect that one
+                vetter_results = vet.Centroid(lc_name=vetter.lc_name, diff_plots=False, centroid_plots=True).run(tce, tpf)
+                plot_figures.append(plt.gcf())
+                plt.close()
+                results_list.append(vetter_results)
+                
+        # run viz_transits plots
+        transit = vet.VizTransits(transit_plot=True, folded_plot=False).run(tce, lc)
+        transit_plot = plt.gcf()
+        transit_plot.suptitle(plot_name+' Transits')
+        transit_plot.tight_layout()
+        plt.close()
+        diagnostic_plot.savefig(transit_plot)
+
+        folded = vet.VizTransits(transit_plot=False, folded_plot=True).run(tce, lc)
+        folded_plot = plt.gcf()
+        folded_plot.suptitle(plot_name+' Folded Transits')
+        folded_plot.tight_layout()
+        plt.close()
+        diagnostic_plot.savefig(folded_plot)
+        
+        # Save each diagnostic plot stored in plot_figures to diagnostic_plot pdf file
+        for plot in plot_figures:
+            diagnostic_plot.savefig(plot)
+
+        diagnostic_plot.close()
+    
+    # Convert to a single dictionary output
+    results_dict = {k: v for d in results_list for k, v in d.items()} # Combine all dictionaries returned from vetters
+
+    # delete specified metrics
+    for key in remove_metrics:
+        if results_dict.get(key):
+            del results_dict[key]
+    
+    return results_dict
+
+
+def mark_cadences_plot(lc, tce):
+    """return figure object of the lightcurve with epochs oeverplotted"""
+    
+    fig, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(9,5))
+
+    # Get lightcurve data
+    time, flux, time_offset_str = lightkurve_utils.unpack_lk_version(lc, "flux")  # noqa: E50
+    time_offset_q = getattr(exo_const, time_offset_str)
+    epoch = tce.get_epoch(time_offset_q).to_value(u.day)
+    
+    # Get points of lightcurve found to be in transit
+    period = tce["period"].to_value(u.day)
+    dur = tce["duration"].to_value(u.day)
+    intransit = mark_transit_cadences(time, period, epoch, dur)
+
+    # Plot epoch
+    ax1.axvline(x=epoch, lw='0.6', color='r', label='epoch', alpha=0.5)
+
+    # Plot transit train
+    ax1.plot(time, flux, lw=0.72, alpha=0.9)
+    ax1.scatter(time, flux, color='k', s=3, label='cadences', alpha=0.5)
+    
+    # TODO This only plots forward in time from the epoch, works fine assuming tce epoch is first in light curve but not robust
+    transit_epochs = epoch-dur/2
+    while transit_epochs <= time[-1]:
+        ax1.axvline(x=transit_epochs, lw='0.6', color='r', alpha=0.3, ls='--')
+        transit_epochs = transit_epochs+dur
+        ax1.axvline(x=transit_epochs, lw='0.6', color='r', alpha=0.3, ls='--')
+        transit_epochs = transit_epochs-dur + period
+        
+    # Plot cadences in transit
+    ax1.scatter(time[intransit], flux[intransit], color='r', s=4, label='cadences in transit');
+
+    # Plotting params
+    ax1.set_ylabel('Flux')
+    ax1.set_xlabel('Time '+time_offset_str)
+    ax1.set_title(lc.label+' period='+'{0:.2f}'.format(period)+'d, dur='+'{0:.2f}'.format(dur)+'d')
+    ax1.legend();
+
+    cadences_plot = plt.gcf()
+    plt.close()
+
+    return cadences_plot
+
+    

exovetter/version.py

@@ -5,4 +5,4 @@ try:
     from setuptools_scm import get_version
     version = get_version(root='..', relative_to=__file__)
 except Exception:
-    version = '0.0.6'
+    version = '0.0.7'

exovetter/vetters.py

@@ -6,10 +6,10 @@ from abc import ABC, abstractmethod
 import astropy.units as u
 import numpy as np
 import pandas as pd
-import time as py_time
+# import time as py_time
 import os
-import matplotlib.pyplot as plt
-from matplotlib.backends.backend_pdf import PdfPages
+# import matplotlib.pyplot as plt
+# from matplotlib.backends.backend_pdf import PdfPages
 
 from exovetter.centroid import centroid as cent
 from exovetter import transit_coverage
@@ -26,7 +26,7 @@ from exovetter import leo
 
 __all__ = ['BaseVetter', 'ModShift', 'Lpp', 'OddEven', 
            'TransitPhaseCoverage', 'Sweet', 'Centroid',
-           'VizTransits', 'LeoTransitEvents', 'run_all']
+           'VizTransits', 'LeoTransitEvents']
 
 class BaseVetter(ABC):
     """Base class for vetters.
@@ -585,13 +585,19 @@ class Sweet(BaseVetter):
 class Centroid(BaseVetter):
     """Class to handle centroid vetting"""
 
-    def __init__(self, lc_name="flux"):
+    def __init__(self, lc_name="flux", diff_plots=False, centroid_plots=False):
         """
         Parameters
         ----------
         lc_name : str
             Name of the flux array in the ``lightkurve`` object.
 
+        diff_plots : bool
+            Show centroid difference plots
+
+        centroid_plots : bool
+            Show centroid summary plot
+
         Attributes
         ----------
         tce : tce object
@@ -608,6 +614,8 @@ class Centroid(BaseVetter):
         self.tce = None
         self.tpf = None
         self.metrics = None
+        self.diff_plots = diff_plots
+        self.centroid_plots = centroid_plots
 
     def run(self, tce, lk_tpf, plot=False, remove_transits=None):
         """Runs cent.compute_diff_image_centroids and cent.measure_centroid_shift
@@ -642,6 +650,10 @@ class Centroid(BaseVetter):
         self.tce = tce
         self.tpf = lk_tpf
 
+        if plot:
+            self.diff_plots = True
+            self.centroid_plots = True
+
         time, cube, time_offset_str = lightkurve_utils.unpack_tpf(
             self.tpf, self.lc_name
         )  # noqa: E50
@@ -656,9 +668,9 @@ class Centroid(BaseVetter):
         
         centroids, figs, kept_transits = cent.compute_diff_image_centroids(
             time, cube, period_days, epoch, duration_days, 
-            remove_transits, plot=plot)
+            remove_transits, plot=self.diff_plots)
         
-        offset, signif, fig = cent.measure_centroid_shift(centroids, kept_transits, plot)
+        offset, signif, fig = cent.measure_centroid_shift(centroids, kept_transits, self.centroid_plots)
         figs.append(fig)
 
         # TODO: If plot=True, figs is a list of figure handles.
@@ -901,16 +913,14 @@ class LeoTransitEvents(BaseVetter):
     def plot(self):
         pass
 
-def run_all(tces, lcs, vetters=[VizTransits(), ModShift(), Lpp(), OddEven(), TransitPhaseCoverage(), Sweet(), LeoTransitEvents()], plot=False, verbose=False, plot_dir=None):
-    # TODO Add centroid, maybe rething plotting in general since plotting uses vetter.plot which essentially doubles runtime, 
-    # probably should run initially with vet.run(plot=True) and not store them unless run_all plot=True
-    """Runs vetters and packs results into a dataframe.
+def run_all(tce, lc, vetters=[VizTransits(), ModShift(), Lpp(), OddEven(), TransitPhaseCoverage(), Sweet(), LeoTransitEvents()], remove_metrics = ['plot_data'], plot=False, plot_dir='', plot_name=None ,verbose=False):
+    """Runs vetters on a tce and lc and packs results into a dictionary.
 
     Parameters
     ----------
-    tces: list of tce objects to vet on
+    tces: tce object to vet on
 
-    lc: list of lightkurve objects to vet on
+    lc: lightkurve object to vet on
     
     vetters : list
         List of vetter classes to run
@@ -918,126 +928,180 @@ def run_all(tces, lcs, vetters=[VizTransits(), ModShift(), Lpp(), OddEven(), Tra
     plot : bool
         Toggle diagnostic plots
     
-    plot_dir : str
-        path to store plots in, defaults to current working directory
-    
     verbose : bool
         Toggle timing info and other print statements
 
     Returns
     ------------
-    results : dataframe
-        Pandas dataframe of all the numerical results from the vetters
+    results : dictionary
+        Dictionary of all the numerical results from the vetters
           
     """
 
-    results_dicts = [] # initialize a list to pack results from each tce into
-    tce_names = []
-    run_start = py_time.time()
+    results = run_vetters.run_all(tce, lc, vetters, remove_metrics, plot, plot_dir, plot_name, verbose)
+
+    return results
+
+    # results_list = []
+
+    # if plot == False:
+    #     for vetter in vetters:
+    #         vetter_results = vetter.run(tce, lc, plot=False) # dictionary returned from each vetter
+    #         results_list.append(vetter_results)
+
+    # else:
+    #     
+    #     if plot_name is None:
+    #         plot_name = tce['target'] 
+    #     diagnostic_plot = PdfPages(plot_dir+plot_name+'.pdf') # initialize a pdf to save each figure into
+    #     plot_figures = []
+
+    #     for vetter in vetters:
+    #         vetter_results = vetter.run(tce, lc, plot=True)
+    #         plot_figures.append(plt.gcf())
+    #         plt.close()
+    #         results_list.append(vetter_results)
+
+    #     # Save each diagnostic plot ran on that tce/lc
+    #     for plot in plot_figures:
+    #         diagnostic_plot.savefig(plot)
+
+    #     diagnostic_plot.close()
+
+    # results_dict = {k: v for d in results_list for k, v in d.items()}
+
+    # # delete dictionary entries that are huge arrays to save space
+    # for key in remove_metrics:
+    #     if results_dict.get(key):
+    #         del results_dict[key]
+
+    # return results_dict
+        
+    # OLDER CODE
+        # if plot:
+        #     if vetter.__class__.__name__ != 'VizTransits' and vetter.__class__.__name__ != 'LeoTransitEvents': 
+        #         # viz_transits generates 2 figures so it's handled later, LeoTransitEvents just doesn't have a plot
+        #         vetter.plot()
+        #         vetter_plot = plt.gcf()
+        #         vetter_plot.suptitle(tce['target']+' '+vetter.__class__.__name__)
+        #         vetter_plot.tight_layout()
+        #         plt.close()
+        #         plot_figures.append(vetter_plot)
+
+        # if verbose:
+        #     time_end = py_time.time()
+        #     print(vetter.__class__.__name__, 'finished in', time_end - time_start, 's.')
+        
+        # results_list.append(vetter_results)
+    
+
+    # results_dicts = [] # initialize a list to pack results from each tce into
+    # tce_names = []
+    # run_start = py_time.time()
 
-    if plot_dir is None:
-        plot_dir = os.getcwd()
+    # if plot_dir is None:
+    #     plot_dir = os.getcwd()
     
-    if plot or verbose: 
-        for tce in tces:
-            if 'target' not in tce.keys():
-                print("ERROR: Please supply a 'target' key to all input tces to use the plot or verbose parameters")
-                return
-
-    for tce, lc in zip(tces, lcs):
-        if verbose:
-            print('Vetting', tce['target'], ':')
-
-        tce_names.append(tce['target'])
-        results_list = [] # initialize a list to pack result dictionaries into
+    # if plot or verbose: 
+    #     for tce in tces:
+    #         if 'target' not in tce.keys():
+    #             print("ERROR: Please supply a 'target' key to all input tces to use the plot or verbose parameters")
+    #             return
+
+    # for tce, lc in zip(tces, lcs):
+    #     if verbose:
+    #         print('Vetting', tce['target'], ':')
+
+    #     tce_names.append(tce['target'])
+    #     results_list = [] # initialize a list to pack result dictionaries into
         
-        # run each vetter, if plotting is true fill the figures into a list to save later
-        plot_figures = []
-        for vetter in vetters:
-            time_start = py_time.time()
-            vetter_results = vetter.run(tce, lc)
+    #     # run each vetter, if plotting is true fill the figures into a list to save later
+    #     plot_figures = []
+    #     for vetter in vetters:
+    #         time_start = py_time.time()
+    #         vetter_results = vetter.run(tce, lc)
             
-            if plot:
-                if vetter.__class__.__name__ != 'VizTransits' and vetter.__class__.__name__ != 'LeoTransitEvents': 
-                    # viz_transits generates 2 figures so it's handled later, LeoTransitEvents just doesn't have a plot
-                    vetter.plot()
-                    vetter_plot = plt.gcf()
-                    vetter_plot.suptitle(tce['target']+' '+vetter.__class__.__name__)
-                    vetter_plot.tight_layout()
-                    plt.close()
-                    plot_figures.append(vetter_plot)
-
-            if verbose:
-                time_end = py_time.time()
-                print(vetter.__class__.__name__, 'finished in', time_end - time_start, 's.')
+    #         if plot:
+    #             if vetter.__class__.__name__ != 'VizTransits' and vetter.__class__.__name__ != 'LeoTransitEvents': 
+    #                 # viz_transits generates 2 figures so it's handled later, LeoTransitEvents just doesn't have a plot
+    #                 vetter.plot()
+    #                 vetter_plot = plt.gcf()
+    #                 vetter_plot.suptitle(tce['target']+' '+vetter.__class__.__name__)
+    #                 vetter_plot.tight_layout()
+    #                 plt.close()
+    #                 plot_figures.append(vetter_plot)
+
+    #         if verbose:
+    #             time_end = py_time.time()
+    #             print(vetter.__class__.__name__, 'finished in', time_end - time_start, 's.')
             
-            results_list.append(vetter_results)
+    #         results_list.append(vetter_results)
         
-        if verbose: # add some whitespace for readability
-            print()
-
-        if plot: # save a pdf of each figure made for that vetter
-            diagnostic_plot = PdfPages(plot_dir+tce['target']+'.pdf') # initialize a pdf to save each figure into
-
-            # plot the lightcurve with epochs oeverplotted
-            time, flux, time_offset_str = lightkurve_utils.unpack_lk_version(lc, "flux")  # noqa: E50
-            period = tce["period"].to_value(u.day)
-            dur = tce["duration"].to_value(u.day)
-
-            time_offset_q = getattr(exo_const, time_offset_str)
-            epoch = tce.get_epoch(time_offset_q).to_value(u.day)
-            intransit = utils.mark_transit_cadences(time, period, epoch, dur, num_durations=3, flags=None)
-
-            fig, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(9,5))
-            ax1.plot(time, flux, lw=0.4);
-            ax1.axvline(x=epoch, lw='0.6', color='r', label='epoch');
-            ax1.fill_between(time, 0,1, where=intransit, transform=ax1.get_xaxis_transform(), color='r', alpha=0.15, label='in transit')
-
-            ax1.set_ylabel('Flux')
-            ax1.set_xlabel('Time '+time_offset_str)
-            if 'target' in tce:
-                ax1.set_title(tce['target']);
-
-            ax1.legend();
-            lightcurve_plot = plt.gcf()
-            plt.close()
-            diagnostic_plot.savefig(lightcurve_plot)
-
-            # run viz_transits plots
-            transit = VizTransits(transit_plot=True, folded_plot=False).run(tce, lc)
-            transit_plot = plt.gcf()
-            transit_plot.suptitle(tce['target']+' Transits')
-            transit_plot.tight_layout()
-            plt.close()
-            diagnostic_plot.savefig(transit_plot)
-
-            folded = VizTransits(transit_plot=False, folded_plot=True).run(tce, lc)
-            folded_plot = plt.gcf()
-            folded_plot.suptitle(tce['target']+' Folded Transits')
-            folded_plot.tight_layout()
-            plt.close()
-            diagnostic_plot.savefig(folded_plot)
-
-            # Save each diagnostic plot ran on that tce/lc
-            for plot in plot_figures:
-                diagnostic_plot.savefig(plot)
-
-            diagnostic_plot.close()
+    #     if verbose: # add some whitespace for readability
+    #         print()
+
+    #     if plot: # save a pdf of each figure made for that vetter
+    #         diagnostic_plot = PdfPages(plot_dir+tce['target']+'.pdf') # initialize a pdf to save each figure into
+
+    #         # plot the lightcurve with epochs oeverplotted
+    #         time, flux, time_offset_str = lightkurve_utils.unpack_lk_version(lc, "flux")  # noqa: E50
+    #         period = tce["period"].to_value(u.day)
+    #         dur = tce["duration"].to_value(u.day)
+
+    #         time_offset_q = getattr(exo_const, time_offset_str)
+    #         epoch = tce.get_epoch(time_offset_q).to_value(u.day)
+    #         intransit = utils.mark_transit_cadences(time, period, epoch, dur, num_durations=3, flags=None)
+
+    #         fig, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(9,5))
+    #         ax1.plot(time, flux, lw=0.4);
+    #         ax1.axvline(x=epoch, lw='0.6', color='r', label='epoch');
+    #         ax1.fill_between(time, 0,1, where=intransit, transform=ax1.get_xaxis_transform(), color='r', alpha=0.15, label='in transit')
+
+    #         ax1.set_ylabel('Flux')
+    #         ax1.set_xlabel('Time '+time_offset_str)
+    #         if 'target' in tce:
+    #             ax1.set_title(tce['target']);
+
+    #         ax1.legend();
+    #         lightcurve_plot = plt.gcf()
+    #         plt.close()
+    #         diagnostic_plot.savefig(lightcurve_plot)
+
+    #         # run viz_transits plots
+    #         transit = VizTransits(transit_plot=True, folded_plot=False).run(tce, lc)
+    #         transit_plot = plt.gcf()
+    #         transit_plot.suptitle(tce['target']+' Transits')
+    #         transit_plot.tight_layout()
+    #         plt.close()
+    #         diagnostic_plot.savefig(transit_plot)
+
+    #         folded = VizTransits(transit_plot=False, folded_plot=True).run(tce, lc)
+    #         folded_plot = plt.gcf()
+    #         folded_plot.suptitle(tce['target']+' Folded Transits')
+    #         folded_plot.tight_layout()
+    #         plt.close()
+    #         diagnostic_plot.savefig(folded_plot)
+
+    #         # Save each diagnostic plot ran on that tce/lc
+    #         for plot in plot_figures:
+    #             diagnostic_plot.savefig(plot)
+
+    #         diagnostic_plot.close()
         
-        # put all values from each results dictionary into a single dictionary
-        results_dict = {k: v for d in results_list for k, v in d.items()}
+    #     # put all values from each results dictionary into a single dictionary
+    #     results_dict = {k: v for d in results_list for k, v in d.items()}
         
-        # delete dictionary entries that are huge arrays to save space
-        if results_dict.get('plot_data'):
-            del results_dict['plot_data']
+    #     # delete dictionary entries that are huge arrays to save space
+    #     if results_dict.get('plot_data'):
+    #         del results_dict['plot_data']
         
-        # add the dictionary to the final list
-        results_dicts.append(results_dict)
+    #     # add the dictionary to the final list
+    #     results_dicts.append(results_dict)
 
-    results_df = pd.DataFrame(results_dicts) # Put the values from each result dictionary into a dataframe
+    # results_df = pd.DataFrame(results_dicts) # Put the values from each result dictionary into a dataframe
     
-    results_df.insert(loc=0, column='tce', value=tce_names)
-    if verbose:
-        print('Execution time:', (py_time.time() - run_start), 's')
+    # results_df.insert(loc=0, column='tce', value=tce_names)
+    # if verbose:
+    #     print('Execution time:', (py_time.time() - run_start), 's')
 
-    return results_df
+    # return results_df

{exovetter-0.0.6.dist-info → exovetter-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: exovetter
-Version: 0.0.6
+Version: 0.0.7
 Summary: Exoplanet vetting package
 Home-page: https://github.com/spacetelescope/exovetter
 Author: Susan Mullally et al.

{exovetter-0.0.6.dist-info → exovetter-0.0.7.dist-info}/RECORD

@@ -9,9 +9,9 @@ exovetter/sweet.py,sha256=prbuteEaahFWhAoCtQCVP47SbA6h4pYJn1Wn9JkEalc,3066
 exovetter/tce.py,sha256=5JFKkbKoKCtdhm5EuW6FMAvp0LiaHLuqpFUbY0joyLI,7302
 exovetter/transit_coverage.py,sha256=Wix6TaQmEgRxlEZKB6WF3OFQVXqtJN1tBkltFaMDrHM,2194
 exovetter/trapezoid_fit.py,sha256=Dok-H0zRsfigh4zfVO4R6Wi2TgK6hQXh4EIIYGouxiQ,31097
-exovetter/utils.py,sha256=4HNRJkzgHI9XlRYvPSLZqJIQMG8ihX0UujSSTpiRTvU,18430
-exovetter/version.py,sha256=EnOl1cJ7hjy3aYox8oAzHbnkOWXlNbTHGaVr_NVNfR0,337
-exovetter/vetters.py,sha256=MRQjRR-PDXuPfGk5Z0DuW4muOpTsp6ygp47lGpnChZ8,35132
+exovetter/utils.py,sha256=1K34N6sQ7iomf4oFHyqGubcDhNwTa2lF_uKEOGJGrCk,24909
+exovetter/version.py,sha256=Es0ObF1J9qSSraJcBVdj4CHe2laI8JXK6MYDVl2LypM,337
+exovetter/vetters.py,sha256=ONNZM3qhVRd_s6By-wR7VBuas8tyo_TwtrpiS2x4_XE,37423
 exovetter/viz_transits.py,sha256=FUc8DEedaQQ8YDoeVvR1QyGPmh2oPGmVg27W3WrVguQ,5648
 exovetter/centroid/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 exovetter/centroid/centroid.py,sha256=LWqjn-Oerdw5j2wDCFYqB6omE4K9gckIwAA0-WZvgkY,8655
@@ -21,8 +21,8 @@ exovetter/centroid/fastpsffit.py,sha256=eRMxYUJ_4hsCxso4u1d1zQvFSJQlJ_gRzhNa2PXk
 exovetter/modshift/__init__.py,sha256=j5665q0RHVzbzdPBXv_jUozGB4sex8ANXtzB41EYzRQ,68
 exovetter/modshift/modshift.py,sha256=VEnj7ITvYRfqICyRiNeCZ9tqQ4d4fPOw8avB6TTbhIU,14773
 exovetter/modshift/plotmodshift.py,sha256=MMLkvxkOqBGIYGPN97_WtrHgTZsDzY_XRRNswhz5YQI,2452
-exovetter-0.0.6.dist-info/LICENSE.rst,sha256=uhiFz7eEG8WszLtRtYIT89FNMI3ijy1aACnvl5BOz2Y,1492
-exovetter-0.0.6.dist-info/METADATA,sha256=ionvGOGowwq37EvLogal4vsPZ46y5oKK4SxQOEvgTW0,3706
-exovetter-0.0.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-exovetter-0.0.6.dist-info/top_level.txt,sha256=wh0_U5IPEspONX8zhGRaFUqfuovCGkgYjAmWuQe0w6Q,10
-exovetter-0.0.6.dist-info/RECORD,,
+exovetter-0.0.7.dist-info/LICENSE.rst,sha256=uhiFz7eEG8WszLtRtYIT89FNMI3ijy1aACnvl5BOz2Y,1492
+exovetter-0.0.7.dist-info/METADATA,sha256=nXJOHqH5ayjdJ7idVePETqwxsiD8RKpI0JQBUoZ0Epc,3706
+exovetter-0.0.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+exovetter-0.0.7.dist-info/top_level.txt,sha256=wh0_U5IPEspONX8zhGRaFUqfuovCGkgYjAmWuQe0w6Q,10
+exovetter-0.0.7.dist-info/RECORD,,

{exovetter-0.0.6.dist-info → exovetter-0.0.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any