arvi 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

arvi/reports.py

@@ -2,7 +2,7 @@ from functools import partial
 import numpy as np
 from astropy.timeseries import LombScargle
 
-from .setup_logger import logger
+from .setup_logger import setup_logger
 
 
 sine_line = None
@@ -27,104 +27,178 @@ def sine_picker(event, self, fig, ax, ax1):
     fig.canvas.draw_idle()
 
 
-def summary(self, add_ccf_mask=True, add_prog_id=False):
-    from .utils import pretty_print_table
-    rows = []
-    rows.append([self.star] + [''] * len(self.instruments))
-    rows.append([''] + self.instruments)
-    rows.append(['N'] + list(self.NN.values()))
-
-    if add_ccf_mask:
-        row = ['CCF mask']
-        for inst in self.instruments:
-            row.append(', '.join(np.unique(getattr(self, inst).ccf_mask)))
-        rows.append(row)
-
-    if add_prog_id:
-        row = ['prog ID']
-        for inst in self.instruments:
-            p = ', '.join(np.unique(getattr(self, inst).prog_id))
-            row.append(p)
-        rows.append(row)
-
-    pretty_print_table(rows)
-
-
-def report(self, save=None):
-    import matplotlib.pyplot as plt
-    import matplotlib.gridspec as gridspec
-    from matplotlib.backends.backend_pdf import PdfPages
-
-    # size = A4
-    size = 8.27, 11.69
-    fig = plt.figure(figsize=size, constrained_layout=True)
-    gs = gridspec.GridSpec(5, 3, figure=fig, height_ratios=[2, 2, 1, 1, 0.1])
-
-    # first row, all columns
-    ax1 = plt.subplot(gs[0, :])
-
-    title = f'{self.star}'
-    ax1.set_title(title, loc='left', fontsize=14)
-    # ax1.set_title(r"\href{http://www.google.com}{link}", color='blue',
-    #               loc='center')
-
-    if self._did_adjust_means:
-        title = '(instrument means subtracted) '
-    else:
-        title = ''
-    title += f'V={self.simbad.V}, {self.simbad.sp_type}'
-    ax1.set_title(title, loc='right', fontsize=12)
-
-    self.plot(ax=ax1, N_in_label=True, tooltips=False, remove_50000=True)
-
-
-    ax1.legend().remove()
-    legend_ax = plt.subplot(gs[1, -1])
-    legend_ax.axis('off')
-    leg = plt.legend(*ax1.get_legend_handles_labels(),
-                     prop={'family': 'monospace'})
-    legend_ax.add_artist(leg)
-    second_legend = f'rms  : {self.rms:.2f} {self.units}\n'
-    second_legend += f'error: {self.error:.2f} {self.units}'
-    legend_ax.legend([],
-                     title=second_legend,
-                     loc='lower right', frameon=False,
-                     prop={'family': 'monospace'})
-
-    ax2 = plt.subplot(gs[1, :-1])
-    self.gls(ax=ax2, picker=True)
-
-    ax3 = plt.subplot(gs[2, :-1])
-    self.plot_fwhm(ax=ax3, tooltips=False, remove_50000=True)
-    ax3.legend().remove()
-    ax3p = plt.subplot(gs[2, -1])
-    self.gls_fwhm(ax=ax3p, picker=False)
-
-    ax4 = plt.subplot(gs[3, :-1])
-    self.plot_bis(ax=ax4, tooltips=False, remove_50000=True)
-    ax4.legend().remove()
-    ax4p = plt.subplot(gs[3, -1])
-    self.gls_bis(ax=ax4p, picker=False)
-
-
-    if save is None:
-        fig.canvas.mpl_connect(
-            'pick_event',
-            partial(sine_picker, self=self, fig=fig, ax=ax2, ax1=ax1))
-
-    if save is not None:
-        if save is True:
-            save = f'report_{"".join(self.star.split())}.pdf'
-
-        if save.endswith('.png'):
-            fig.savefig(save)
+class REPORTS:
+    def summary(self, add_ccf_mask=True, add_prog_id=False, **kwargs):
+        from .utils import pretty_print_table
+        if isinstance(self, list):
+            selfs = self
         else:
-            with PdfPages(save) as pdf:
-                #pdf.attach_note('hello', positionRect=[5, 15, 20, 30])
-
-                if self.verbose:
-                    logger.info(f'saving to {save}')
-                pdf.savefig(fig)
-            # os.system(f'evince {save} &')
-
-    return fig
+            selfs = [self]
+        
+        rows = []
+        for self in selfs:
+            rows.append([self.star] + [''] * len(self.instruments) + [''])
+            rows.append([''] + self.instruments + ['full'])
+            rows.append(['N'] + list(self.NN.values()) + [self.N])
+            rows.append(['RV span'] + [np.ptp(s.mvrad).round(3) for s in self] + [np.ptp(self.mvrad).round(3)])
+            rows.append(['RV std'] + [s.mvrad.std().round(3) for s in self] + [self.mvrad.std().round(3)])
+            rows.append(['eRV mean'] + [s.msvrad.mean().round(3) for s in self] + [self.msvrad.mean().round(3)])
+
+            if add_ccf_mask:
+                if hasattr(self, 'ccf_mask'):
+                    row = ['CCF mask']
+                    for inst in self.instruments:
+                        row.append(', '.join(np.unique(getattr(self, inst).ccf_mask)))
+                    row.append('')
+                    rows.append(row)
+
+            if add_prog_id:
+                row = ['prog ID']
+                for inst in self.instruments:
+                    p = ', '.join(np.unique(getattr(self, inst).prog_id))
+                    row.append(p)
+                rows.append(row)
+
+        return pretty_print_table(rows, **kwargs)
+
+
+    def summary_one_instrument(self):
+        from .utils import pretty_print_table
+        if isinstance(self, list):
+            selfs = self
+        else:
+            selfs = [self]
+
+        rows = []
+        rows.append(['', 'N', 'Δt', 'RV std', 'median σRV'])
+        for self in selfs:
+            rows.append([
+                self.star, 
+                self.N, 
+                int(np.ptp(self.mtime).round(0)),
+                np.std(self.mvrad).round(1),
+                np.median(self.msvrad).round(1),
+            ])
+
+        pretty_print_table(rows)
+
+
+    def summary_stellar(self, show_ra_dec=True, show_pm=True, **kwargs):
+        from .utils import pretty_print_table, get_ra_sexagesimal, get_dec_sexagesimal
+        if isinstance(self, list):
+            selfs = self
+        else:
+            selfs = [self]
+        
+
+
+        rows = []
+        rows.append(['star'] + [self.star for self in selfs])
+        if show_ra_dec:
+            rows.append(['RA'] + [get_ra_sexagesimal(self.simbad.ra) for self in selfs])
+            rows.append(['DEC'] + [get_dec_sexagesimal(self.simbad.dec) for self in selfs])
+        
+        if show_pm:
+            rows.append(['pm ra'] + [(self.gaia or self.simbad).pmra for self in selfs])
+            rows.append(['pm dec'] + [(self.gaia or self.simbad).pmdec for self in selfs])
+
+        rows.append(['π (mas)'] + [(self.gaia or self.simbad).plx for self in selfs])
+        # 
+        rows.append(['B (mag)'] + [self.simbad._B for self in selfs])
+        rows.append(['V (mag)'] + [self.simbad._V for self in selfs])
+        rows.append(['B-V'] + [self.simbad._B - self.simbad._V for self in selfs])
+        rows.append(["log R'HK"] + [np.nanmean(self.rhk).round(2) for self in selfs])
+            # rows.append([''] + self.instruments + ['full'])
+            # rows.append(['N'] + list(self.NN.values()) + [self.N])
+            # rows.append(['RV span'] + [np.ptp(s.mvrad).round(3) for s in self] + [np.ptp(self.mvrad).round(3)])
+            # rows.append(['RV std'] + [s.mvrad.std().round(3) for s in self] + [self.mvrad.std().round(3)])
+            # rows.append(['eRV mean'] + [s.msvrad.mean().round(3) for s in self] + [self.msvrad.mean().round(3)])
+
+        return pretty_print_table(rows, **kwargs)
+
+
+
+
+    def report(self, save=None):
+        import matplotlib.pyplot as plt
+        import matplotlib.gridspec as gridspec
+        from matplotlib.backends.backend_pdf import PdfPages
+        logger = setup_logger()
+
+        # size = A4
+        size = 8.27, 11.69
+        fig = plt.figure(figsize=size, constrained_layout=True)
+        gs = gridspec.GridSpec(5, 3, figure=fig, height_ratios=[2, 2, 1, 1, 0.1])
+
+        # first row, all columns
+        ax1 = plt.subplot(gs[0, :])
+
+        title = f'{self.star}'
+        ax1.set_title(title, loc='left', fontsize=14)
+        # ax1.set_title(r"\href{http://www.google.com}{link}", color='blue',
+        #               loc='center')
+
+        if self._did_adjust_means:
+            title = '(instrument means subtracted) '
+        else:
+            title = ''
+        title += f'V={self.simbad.V}, {self.simbad.sp_type}'
+        ax1.set_title(title, loc='right', fontsize=12)
+
+        self.plot(ax=ax1, N_in_label=True, tooltips=False, remove_50000=True)
+
+
+        ax1.legend().remove()
+        legend_ax = plt.subplot(gs[1, -1])
+        legend_ax.axis('off')
+        leg = plt.legend(*ax1.get_legend_handles_labels(),
+                        prop={'family': 'monospace'})
+        legend_ax.add_artist(leg)
+        
+        second_legend = f'rms  : {self.rms:.2f} {self.units}'
+        second_legend += f'\nerror: {self.error:.2f} {self.units}'
+
+        second_legend += f'\n\nCCF masks: {np.unique(self.ccf_mask)}'
+
+        legend_ax.legend([],
+                        title=second_legend,
+                        loc='lower right', frameon=False,
+                        prop={'family': 'monospace'})
+
+        ax2 = plt.subplot(gs[1, :-1])
+        self.gls(ax=ax2, picker=True)
+
+        ax3 = plt.subplot(gs[2, :-1])
+        self.plot_fwhm(ax=ax3, tooltips=False, remove_50000=True)
+        ax3.legend().remove()
+        ax3p = plt.subplot(gs[2, -1])
+        self.gls_fwhm(ax=ax3p, picker=False)
+
+        ax4 = plt.subplot(gs[3, :-1])
+        self.plot_rhk(ax=ax4, tooltips=False, remove_50000=True)
+        ax4.legend().remove()
+        ax4p = plt.subplot(gs[3, -1])
+        self.gls_rhk(ax=ax4p, picker=False)
+
+
+        if save is None:
+            fig.canvas.mpl_connect(
+                'pick_event',
+                partial(sine_picker, self=self, fig=fig, ax=ax2, ax1=ax1))
+
+        if save is not None:
+            if save is True:
+                save = f'report_{"".join(self.star.split())}.pdf'
+
+            if save.endswith('.png'):
+                fig.savefig(save)
+            else:
+                with PdfPages(save) as pdf:
+                    #pdf.attach_note('hello', positionRect=[5, 15, 20, 30])
+
+                    if self.verbose:
+                        logger.info(f'saving to {save}')
+                    pdf.savefig(fig)
+                # os.system(f'evince {save} &')
+
+        return fig

arvi/setup_logger.py

@@ -1,11 +1,24 @@
 import sys
-from loguru import logger
 
-logger.remove()
-logger.configure(extra={"indent": ""})
-logger.add(
-    sys.stdout,
-    colorize=True,
-    # format="<green>{time:YYYY-MM-DDTHH:mm:ss}</green> <level>{message}</level>",
-    format="{extra[indent]}<level>{message}</level>",
-)
+def setup_logger():
+    from loguru import logger
+    try:
+        import marimo as mo
+        if mo.running_in_notebook():
+            raise NotImplementedError
+    except NotImplementedError:
+        pass
+    except (ImportError, ModuleNotFoundError):
+        logger.remove()
+    else:
+        logger.remove()
+
+    logger.configure(extra={"indent": ""})
+    logger.add(
+        sys.stdout,
+        colorize=True,
+        # format="<green>{time:YYYY-MM-DDTHH:mm:ss}</green> <level>{message}</level>",
+        format="{extra[indent]}<level>{message}</level>",
+    )
+
+    return logger

arvi/simbad_wrapper.py

@@ -1,9 +1,8 @@
 import os
-import numpy as np
 import requests
 from dataclasses import dataclass
 
-import pysweetcat
+import numpy as np
 
 try:
     from uncertainties import ufloat
@@ -12,7 +11,6 @@ except ImportError:
 
 from .stellar import EFFECTIVE_TEMPERATURES, teff_to_sptype
 from .translations import translate
-from .setup_logger import logger
 
 DATA_PATH = os.path.dirname(__file__)
 DATA_PATH = os.path.join(DATA_PATH, 'data')
@@ -146,6 +144,7 @@ class simbad:
             star (str): The name of the star to query simbad
         """
         from astropy.coordinates import SkyCoord
+        import pysweetcat
 
         self.star = translate(star, ngc=True, ic=True)
 
@@ -170,41 +169,52 @@ class simbad:
             if _debug:
                 print('table1:', table1)
             cols, values = parse_table1(table1)
+        except IndexError:
+            raise ValueError(f'simbad query for {star} failed') from None
 
+        try:
             table2 = run_query(query=BV_QUERY.format(star=self.star))
             if _debug:
                 print('table2:', table2)
             cols, values = parse_table1(table2, cols, values)
+        except IndexError:
+            self.B = self.V = np.nan
 
+        try:
             table3 = run_query(query=IDS_QUERY.format(star=self.star))
             if _debug:
                 print('table3:', table3)
             line = table3.splitlines()[2]
             self.ids = line.replace('"', '').replace('    ', ' ').replace('   ', ' ').replace('  ', ' ').split('|')
+        except IndexError:
+            self.ids = []
+
+        table4 = run_query(query=FILTERS_QUERY.format(star=self.star))
+        if _debug:
+            print('table4:\n', table4)
+        for row in table4.splitlines()[2:]:
+            filter_name, mag, mag_err, bibcode = row.replace('"', '').split('|')
+            filter_name = filter_name.strip()
+            try:
+                setattr(self, '_' + filter_name, ufloat(float(mag), float(mag_err)))
+            except ValueError:
+                setattr(self, '_' + filter_name, float(mag))
 
-            table4 = run_query(query=FILTERS_QUERY.format(star=self.star))
-            for row in table4.splitlines()[2:]:
-                filter_name, mag, mag_err, bibcode = row.replace('"', '').split('|')
-                filter_name = filter_name.strip()
-                try:
-                    setattr(self, '_' + filter_name, ufloat(float(mag), float(mag_err)))
-                except ValueError:
-                    setattr(self, '_' + filter_name, float(mag))
-
-            # measurements table
-            table5 = run_query(query=MEAS_QUERY.format(star=self.star))
-            _teff, _logg, _feh, _bibcode = [], [], [], []
-            for row in table5.splitlines()[2:]:
-                teff, log_g, log_g_prec, fe_h, fe_h_prec, bibcode = row.replace('"', '').split('|')
-                _bibcode.append(bibcode)
-                _teff.append(parse_value(teff))
-                _logg.append(parse_value(log_g, prec=log_g_prec))
-                _feh.append(parse_value(fe_h, prec=fe_h_prec))
-
-            self.measurements = Measurements(_teff, _logg, _feh, _bibcode)
+        # measurements table
+        table5 = run_query(query=MEAS_QUERY.format(star=self.star))
+        if _debug:
+            print('table5:\n', table5)
+
+        _teff, _logg, _feh, _bibcode = [], [], [], []
+        for row in table5.splitlines()[2:]:
+            teff, log_g, log_g_prec, fe_h, fe_h_prec, bibcode = row.replace('"', '').split('|')
+            _bibcode.append(bibcode)
+            _teff.append(parse_value(teff))
+            _logg.append(parse_value(log_g, prec=log_g_prec))
+            _feh.append(parse_value(fe_h, prec=fe_h_prec))
+
+        self.measurements = Measurements(_teff, _logg, _feh, _bibcode)
 
-        except IndexError:
-            raise ValueError(f'simbad query for {star} failed') from None
 
         try:
             self.gaia_id = int([i for i in self.ids if 'Gaia DR3' in i][0]
@@ -245,8 +255,9 @@ class simbad:
 
         except IndexError:
             if self.sp_type == '':
-                self.teff = int(np.mean(self.measurements.teff))
-                self.sp_type = teff_to_sptype(self.teff)
+                if len(self.measurements.teff) > 0:
+                    self.teff = int(np.mean(self.measurements.teff))
+                    self.sp_type = teff_to_sptype(self.teff)
             elif self.sp_type[:2] in EFFECTIVE_TEMPERATURES:
                 self.teff = EFFECTIVE_TEMPERATURES[self.sp_type[:2]]
 

arvi/timeseries.py

@@ -1,23 +1,28 @@
 import os
 from dataclasses import dataclass, field
 from typing import Union
-from functools import lru_cache, partial, partialmethod
+from functools import partial, partialmethod
 from glob import glob
 import warnings
 from copy import deepcopy
 from datetime import datetime, timezone
 import numpy as np
 
-from .setup_logger import logger
+from .setup_logger import setup_logger
+logger = setup_logger()
+
 from .config import config
 from .translations import translate
 from .dace_wrapper import do_download_filetype, do_symlink_filetype, get_observations, get_arrays
 from .simbad_wrapper import simbad
 from .gaia_wrapper import gaia
+from .exofop_wrapper import exofop
 from .extra_data import get_extra_data
 from .stats import wmean, wrms
 from .binning import bin_ccf_mask, binRV
 from .HZ import getHZ_period
+from .instrument_specific import ISSUES
+from .reports import REPORTS
 from .utils import sanitize_path, strtobool, there_is_internet, timer, chdir
 from .utils import lazy_import
 
@@ -30,8 +35,8 @@ class ExtraFields:
         return list(self.__dict__.keys())
 
 
-@dataclass
-class RV:
+@dataclass(order=False)
+class RV(ISSUES, REPORTS):
     """
     A class holding RV observations
 
@@ -68,23 +73,29 @@ class RV:
     _did_adjust_means: bool = field(init=False, repr=False, default=False)
     _did_simbad_query: bool = field(init=False, repr=False, default=False)
     _did_gaia_query: bool = field(init=False, repr=False, default=False)
+    _did_toi_query: bool = field(init=False, repr=False, default=False)
     _raise_on_error: bool = field(init=True, repr=False, default=True)
+    __masked_numbers: bool = field(init=False, repr=False, default=False)
     # 
     _simbad = None
     _gaia = None
+    _toi = None
 
     def __repr__(self):
         ni = len(self.instruments)
         if self.N == 0:
             return f"RV(star='{self.star}', N=0)"
 
-        i = f'{ni} instrument' + ('s' if ni > 1 else '')
+        if self._child:
+            i = ''
+        else:
+            i = f', {ni} instrument' + ('s' if ni > 1 else '')
 
         if self.time.size == self.mtime.size:
-            return f"RV(star='{self.star}', N={self.N}, {i})"
+            return f"RV(star='{self.star}', N={self.N}{i})"
         else:
             nmasked = self.N - self.mtime.size
-            return f"RV(star='{self.star}', N={self.N}, masked={nmasked}, {i})"
+            return f"RV(star='{self.star}', N={self.N}, masked={nmasked}{i})"
 
     @property
     def simbad(self):
@@ -144,6 +155,26 @@ class RV:
         self._did_gaia_query = True
         return self._gaia
 
+    @property
+    def toi(self):
+        if self._toi is not None:
+            return self._toi
+
+        if 'TOI' not in self.__star__ or 'TIC' not in self.__star__ or self._child or self._did_toi_query:
+            return None
+
+        if self.verbose:
+            logger.info('querying ExoFOP...')
+
+        try:
+            self._toi = exofop(self.__star__)
+        except ValueError:
+            if self.verbose:
+                logger.error(f'ExoFOP query for {self.__star__} failed')
+
+        self._did_toi_query = True
+        return self._toi
+
     def __post_init_special_sun(self):
         import pickle
         from .extra_data import get_sun_data
@@ -168,7 +199,7 @@ class RV:
                 import concurrent.futures
                 with timer('simbad and gaia queries'):
                     with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
-                        executor.map(self.__getattribute__, ('simbad', 'gaia'))
+                        executor.map(self.__getattribute__, ('simbad', 'gaia', 'toi'))
 
                 # with timer('simbad query'):
                 #     self.simbad
@@ -241,7 +272,6 @@ class RV:
             # all other quantities
             self._build_arrays()
 
-
             if self.load_extra_data:
                 if isinstance(self.load_extra_data, str):
                     path = self.load_extra_data
@@ -314,6 +344,16 @@ class RV:
         for inst in self.instruments:
             yield getattr(self, inst)
 
+    @property
+    def _masked_numbers(self):
+        return self.__masked_numbers
+
+    @_masked_numbers.setter
+    def _masked_numbers(self, value):
+        self.__masked_numbers = value
+        if not self._child:
+            for s in self:
+                s._masked_numbers = value
 
     def reload(self):
         self._did_secular_acceleration = False
@@ -335,19 +375,35 @@ class RV:
     @property
     def N(self) -> int:
         """Total number of observations"""
+        if self._masked_numbers:
+            return self.mtime.size
         return self.time.size
 
     @property
     def NN(self):
         """ Total number of observations per instrument """
+        if self._child:
+            return {self.instruments[0]: self.N}
         return {inst: getattr(self, inst).N for inst in self.instruments}
 
     @property
     def N_nights(self) -> int:
         """ Number of individual nights """
-        if self.mtime.size == 0:
-            return 0
-        return binRV(self.mtime, None, None, binning_bins=True).size - 1
+        def get_nights(t):
+            return binRV(t, None, None, binning_bins=True).size - 1
+
+        if self._masked_numbers:
+            if self._child:
+                return get_nights(self.mtime)
+            else:
+                return sum([get_nights(s.mtime) for s in self])
+        else:
+            if self._child:
+                return get_nights(self.time)
+            else:
+                return sum([get_nights(s.time) for s in self])
+        # return binRV(_t, None, None, binning_bins=True).size - 1
+        # return sum(list(self.NN.values()))
 
     @property
     def NN_nights(self):
@@ -516,8 +572,8 @@ class RV:
         return s
 
     @classmethod
-    def from_rdb(cls, files, star=None, instrument=None, units='ms', 
-                 header_skip=2, **kwargs):
+    def from_rdb(cls, files, star=None, instrument=None, instrument_suffix=None,
+                 units='ms', header_skip=2, **kwargs):
         """ Create an RV object from an rdb file or a list of rdb files
 
         Args:
@@ -568,6 +624,9 @@ class RV:
         if instruments.size == 1 and len(files) > 1:
             instruments = np.repeat(instruments, len(files))
 
+        if instrument_suffix is not None:
+            instruments = [i + instrument_suffix for i in instruments]
+
         factor = 1e3 if units == 'kms' else 1.0
 
         s = cls(star, _child=True, **kwargs)
@@ -744,6 +803,8 @@ class RV:
 
         s._child = False
         s.instruments = list(map(str, instruments))
+        s.filenames = list(map(str, files))
+
         s._build_arrays()
 
         if kwargs.get('do_adjust_means', False):
@@ -1188,9 +1249,9 @@ class RV:
 
     from .plots import plot, plot_fwhm, plot_bispan, plot_contrast, plot_rhk, plot_berv, plot_quantity
     from .plots import gls, gls_fwhm, gls_bispan, gls_rhk, gls_quantity, window_function
-    from .reports import report
 
-    from .instrument_specific import known_issues
+    # from .reports import report
+    # from .instrument_specific import known_issues
 
     def change_instrument_name(self, old_name, new_name, strict=False):
         """ Change the name of an instrument

arvi/utils.py

@@ -21,7 +21,7 @@ except ImportError:
     tqdm = lambda x, *args, **kwargs: x
     trange = lambda *args, **kwargs: range(*args, **kwargs)
 
-from .setup_logger import logger
+from .setup_logger import setup_logger
 from .config import config
 
 
@@ -70,6 +70,8 @@ def all_logging_disabled():
 @contextmanager
 def timer(name=None):
     """ A simple context manager to time a block of code """
+    logger = setup_logger()
+
     if not config.debug:
         yield
         return

{arvi-0.2.1.dist-info → arvi-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arvi
-Version: 0.2.1
+Version: 0.2.3
 Summary: The Automated RV Inspector
 Author-email: João Faria <joao.faria@unige.ch>
 License: MIT