arvi 0.2.11__tar.gz → 0.3.0__tar.gz

{arvi-0.2.11 → arvi-0.3.0}/.github/workflows/docs-gh-pages.yml

@@ -26,7 +26,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         
       - name: Setup Pages
         uses: actions/configure-pages@v5

{arvi-0.2.11 → arvi-0.3.0}/.github/workflows/install.yml

@@ -16,7 +16,7 @@ jobs:
         python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
 
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v6
       with:

{arvi-0.2.11 → arvi-0.3.0}/.github/workflows/python-publish.yml

@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
     - name: Set up Python
       uses: actions/setup-python@v6
       with:

{arvi-0.2.11/arvi.egg-info → arvi-0.3.0}/PKG-INFO

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

{arvi-0.2.11 → arvi-0.3.0}/arvi/__init__.py

@@ -20,6 +20,7 @@ def __getattr__(name: str):
     if name in (
         '_ipython_canary_method_should_not_exist_',
         '_ipython_display_',
+        '__custom_documentations__',
         '_repr_mimebundle_',
         '__wrapped__'
     ):

{arvi-0.2.11 → arvi-0.3.0}/arvi/dace_wrapper.py

@@ -229,55 +229,81 @@ def get_observations_from_instrument(star, instrument, user=None, main_id=None,
                 mask3 = mask2 & (result['ins_mode'] == ins_mode)
                 _nan = np.full(mask3.sum(), np.nan)
 
-                r[str(inst)][str(pipe)][str(ins_mode)] = {
-                    'texp': result['texp'][mask3],
-                    'bispan': result['spectro_ccf_bispan'][mask3],
-                    'bispan_err': result['spectro_ccf_bispan_err'][mask3],
-                    'drift_noise': result['spectro_cal_drift_noise'][mask3],
-                    'rjd': result['obj_date_bjd'][mask3],
-                    'cal_therror': _nan,
-                    'fwhm': result['spectro_ccf_fwhm'][mask3],
-                    'fwhm_err': result['spectro_ccf_fwhm_err'][mask3],
-                    'rv': result['spectro_ccf_rv'][mask3],
-                    'rv_err': result['spectro_ccf_rv_err'][mask3],
-                    'berv': result['spectro_cal_berv'][mask3],
-                    'ccf_noise': np.sqrt(
-                        np.square(result['spectro_ccf_rv_err'][mask3]) - np.square(result['spectro_cal_drift_noise'][mask3])
-                    ),
-                    'rhk': result['spectro_analysis_rhk'][mask3],
-                    'rhk_err': result['spectro_analysis_rhk_err'][mask3],
-                    'contrast': result['spectro_ccf_contrast'][mask3],
-                    'contrast_err': result['spectro_ccf_contrast_err'][mask3],
-                    'cal_thfile': result['spectro_cal_thfile'][mask3],
-                    'spectroFluxSn50': result['spectro_flux_sn50'][mask3],
-                    'protm08': result['spectro_analysis_protm08'][mask3],
-                    'protm08_err': result['spectro_analysis_protm08_err'][mask3],
-                    'caindex': result['spectro_analysis_ca'][mask3],
-                    'caindex_err': result['spectro_analysis_ca_err'][mask3],
-                    'pub_reference': result['pub_ref'][mask3],
-                    'drs_qc': result['spectro_drs_qc'][mask3],
-                    'haindex': result['spectro_analysis_halpha'][mask3],
-                    'haindex_err': result['spectro_analysis_halpha_err'][mask3],
-                    'protn84': result['spectro_analysis_protn84'][mask3],
-                    'protn84_err': result['spectro_analysis_protn84_err'][mask3],
-                    'naindex': result['spectro_analysis_na'][mask3],
-                    'naindex_err': result['spectro_analysis_na_err'][mask3],
-                    'snca2': _nan,
-                    'mask': result['spectro_ccf_mask'][mask3],
-                    'public': result['public'][mask3],
-                    'spectroFluxSn20': result['spectro_flux_sn20'][mask3],
-                    'sindex': result['spectro_analysis_smw'][mask3],
-                    'sindex_err': result['spectro_analysis_smw_err'][mask3],
-                    'drift_used': _nan,
-                    'ccf_asym': result['spectro_ccf_asym'][mask3],
-                    'ccf_asym_err': result['spectro_ccf_asym_err'][mask3],
-                    'date_night': result['date_night'][mask3],
-                    'raw_file': result['file_rootpath'][mask3],
-                    'prog_id': result['prog_id'][mask3],
-                    'th_ar': result['th_ar'][mask3],
-                    'th_ar1': result['th_ar1'][mask3],
-                    'th_ar2': result['th_ar2'][mask3],
+                translations = {
+                    'obj_date_bjd': 'rjd',
+                    'spectro_drs_qc': 'drs_qc',
+                    'spectro_cal_berv_mx': 'bervmax',
+                    'pub_ref': 'pub_reference',
+                    'file_rootpath': 'raw_file',
+                    'spectro_ccf_asym': 'ccf_asym',
+                    'spectro_ccf_asym_err': 'ccf_asym_err',
                 }
+                new_result = {}
+                for key in result.keys():
+                    if key in translations:
+                        new_key = translations[key]
+                    else:
+                        new_key = key
+                        new_key = new_key.replace('spectro_ccf_', '')
+                        new_key = new_key.replace('spectro_cal_', '')
+                        new_key = new_key.replace('spectro_analysis_', '')
+                    new_result[new_key] = result[key][mask3]
+
+                new_result['ccf_noise'] = np.sqrt(
+                    np.square(result['spectro_ccf_rv_err'][mask3]) - np.square(result['spectro_cal_drift_noise'][mask3])
+                )
+
+                r[str(inst)][str(pipe)][str(ins_mode)] = new_result
+
+                # r[str(inst)][str(pipe)][str(ins_mode)] = {
+                #     'texp': result['texp'][mask3],
+                #     'bispan': result['spectro_ccf_bispan'][mask3],
+                #     'bispan_err': result['spectro_ccf_bispan_err'][mask3],
+                #     'drift_noise': result['spectro_cal_drift_noise'][mask3],
+                #     'rjd': result['obj_date_bjd'][mask3],
+                #     'cal_therror': _nan,
+                #     'fwhm': result['spectro_ccf_fwhm'][mask3],
+                #     'fwhm_err': result['spectro_ccf_fwhm_err'][mask3],
+                #     'rv': result['spectro_ccf_rv'][mask3],
+                #     'rv_err': result['spectro_ccf_rv_err'][mask3],
+                #     'berv': result['spectro_cal_berv'][mask3],
+                #     'ccf_noise': np.sqrt(
+                #         np.square(result['spectro_ccf_rv_err'][mask3]) - np.square(result['spectro_cal_drift_noise'][mask3])
+                #     ),
+                #     'rhk': result['spectro_analysis_rhk'][mask3],
+                #     'rhk_err': result['spectro_analysis_rhk_err'][mask3],
+                #     'contrast': result['spectro_ccf_contrast'][mask3],
+                #     'contrast_err': result['spectro_ccf_contrast_err'][mask3],
+                #     'cal_thfile': result['spectro_cal_thfile'][mask3],
+                #     'spectroFluxSn50': result['spectro_flux_sn50'][mask3],
+                #     'protm08': result['spectro_analysis_protm08'][mask3],
+                #     'protm08_err': result['spectro_analysis_protm08_err'][mask3],
+                #     'caindex': result['spectro_analysis_ca'][mask3],
+                #     'caindex_err': result['spectro_analysis_ca_err'][mask3],
+                #     'pub_reference': result['pub_ref'][mask3],
+                #     'drs_qc': result['spectro_drs_qc'][mask3],
+                #     'haindex': result['spectro_analysis_halpha'][mask3],
+                #     'haindex_err': result['spectro_analysis_halpha_err'][mask3],
+                #     'protn84': result['spectro_analysis_protn84'][mask3],
+                #     'protn84_err': result['spectro_analysis_protn84_err'][mask3],
+                #     'naindex': result['spectro_analysis_na'][mask3],
+                #     'naindex_err': result['spectro_analysis_na_err'][mask3],
+                #     'snca2': _nan,
+                #     'mask': result['spectro_ccf_mask'][mask3],
+                #     'public': result['public'][mask3],
+                #     'spectroFluxSn20': result['spectro_flux_sn20'][mask3],
+                #     'sindex': result['spectro_analysis_smw'][mask3],
+                #     'sindex_err': result['spectro_analysis_smw_err'][mask3],
+                #     'drift_used': _nan,
+                #     'ccf_asym': result['spectro_ccf_asym'][mask3],
+                #     'ccf_asym_err': result['spectro_ccf_asym_err'][mask3],
+                #     'date_night': result['date_night'][mask3],
+                #     'raw_file': result['file_rootpath'][mask3],
+                #     'prog_id': result['prog_id'][mask3],
+                #     'th_ar': result['th_ar'][mask3],
+                #     'th_ar1': result['th_ar1'][mask3],
+                #     'th_ar2': result['th_ar2'][mask3],
+                # }
     
     # print(r.keys())    
     # print([r[k].keys() for k in r.keys()])

{arvi-0.2.11 → arvi-0.3.0}/arvi/gaia_wrapper.py

@@ -9,7 +9,8 @@ DATA_PATH = os.path.join(DATA_PATH, 'data')
 QUERY = """
 SELECT TOP 20 gaia_source.designation, gaia_source.source_id,
               gaia_source.ra, gaia_source.dec, 
-              gaia_source.parallax, gaia_source.pmra, gaia_source.pmdec,
+              gaia_source.parallax, gaia_source.parallax_error,
+              gaia_source.pmra, gaia_source.pmdec,
               gaia_source.ruwe, gaia_source.phot_g_mean_mag, gaia_source.bp_rp, 
               gaia_source.radial_velocity, gaia_source.radial_velocity_error
 FROM gaiadr3.gaia_source 
@@ -27,7 +28,8 @@ CONTAINS(
 QUERY_ID = """
 SELECT TOP 20 gaia_source.designation, gaia_source.source_id,
               gaia_source.ra, gaia_source.dec, 
-              gaia_source.parallax, gaia_source.pmra, gaia_source.pmdec,
+              gaia_source.parallax, gaia_source.parallax_error,
+              gaia_source.pmra, gaia_source.pmdec,
               gaia_source.ruwe, gaia_source.phot_g_mean_mag, gaia_source.bp_rp, 
               gaia_source.radial_velocity, gaia_source.radial_velocity_error
 FROM gaiadr3.gaia_source 
@@ -120,6 +122,7 @@ class gaia:
         self.pmdec = float(results['pmdec'])
         self.coords = SkyCoord(self.ra, self.dec, unit='deg')
         self.plx = float(results['parallax'])
+        self.plx_err = float(results['parallax_error'])
         try:
             self.radial_velocity = float(results['radial_velocity'])
         except ValueError:
@@ -131,5 +134,12 @@ class gaia:
 
         return
 
+    def distance(self):
+        """ Calculate the distance to the star as 1 / parallax [pc] """
+        from astropy import units as u
+        d = (self.plx * u.mas).to(u.parsec, 
+                                  equivalencies=u.equivalencies.parallax())
+        return d
+
     def __repr__(self):
         return f'{self.star} (DR3 id={self.dr3_id})'

{arvi-0.2.11 → arvi-0.3.0}/arvi/kima_wrapper.py

@@ -1,19 +1,8 @@
 import os
-import numpy as np
+import ast
 
 from .setup_logger import setup_logger
 
-try:
-    import kima
-    from kima.pykima.utils import chdir
-    from kima import distributions
-    from kima import RVData, HGPMdata
-    from kima import RVmodel, GPmodel, RVHGPMmodel
-    kima_available = True
-except ImportError:
-    kima_available = False
-
-
 def try_to_guess_prior(model, prior):
     if 'jitter' in prior:
         return 'Jprior'
@@ -23,8 +12,14 @@ def try_to_guess_prior(model, prior):
 
 
 def run_kima(self, run=False, load=False, run_directory=None,
-             model=RVmodel, priors={}, **kwargs):
-    if not kima_available:
+             model='RVmodel', priors={}, **kwargs):
+    try:
+        import kima
+        from kima.pykima.utils import chdir
+        from kima import distributions
+        from kima import RVData, HGPMdata
+        from kima import RVmodel, GPmodel, RVHGPMmodel
+    except ImportError:
         raise ImportError('kima not available, please install with `pip install kima`')
     
     logger = setup_logger()
@@ -57,7 +52,7 @@ def run_kima(self, run=False, load=False, run_directory=None,
     model.trend = kwargs.pop('trend', False)
     model.degree = kwargs.pop('degree', 0)
 
-    if isinstance(model, RVmodel):
+    if isinstance(model, (RVmodel, RVHGPMmodel)):
         model.studentt = kwargs.pop('studentt', False)
 
     if isinstance(model, GPmodel):
@@ -81,6 +76,16 @@ def run_kima(self, run=False, load=False, run_directory=None,
         model.pm_dec_bary_prior = priors.pop('pm_dec_bary_prior',
                                              distributions.Gaussian(pm_data.pm_dec_hg, pm_data.sig_hg_dec))
 
+    KO = kwargs.pop('known_object', False)
+    if KO:
+        if isinstance(KO, int) and KO is not True:
+            model.set_known_object(KO)
+        else:
+            try:
+                model.set_known_object(kwargs.pop('n_known_object'))
+            except KeyError:
+                msg = 'if `known_object` is True, specify `n_known_object` or pass `known_object` as an integer'
+                raise ValueError(msg) from None
 
     for k, v in priors.items():
         try:
@@ -99,21 +104,27 @@ def run_kima(self, run=False, load=False, run_directory=None,
     if run_directory is None:
         run_directory = os.getcwd()
 
-    if run:
-        # TODO: use signature of kima.run to pop the correct kwargs
-        # model_name = model.__class__.__name__
-        # model_name = f'kima.{model_name}.{model_name}'
-        # signature, defaults = [sig for sig in kima.run.__nb_signature__ if model_name in sig[0]]
+    diagnostic = kwargs.pop('diagnostic', False)
 
+    if run:
+        model_name = model.__class__.__name__
+        model_name = f'kima.{model_name}.{model_name}'
+        signature, _, defaults = [sig for sig in kima._run_really.__nb_signature__ if model_name in sig[0]][0]
+        signature = signature.replace('\\', '')
+        args = ast.parse(signature + ':\n pass').body[0].args
+        defaults = {arg.arg: d for arg, d in zip(args.args[1:], defaults)}
+        defaults.update(kwargs)
         with chdir(run_directory):
-            kima.run(model, **kwargs)
+            kima.run(model, **defaults)
 
     if isinstance(model, RVHGPMmodel):
         data = (data, pm_data)
 
     if load:
         with chdir(run_directory):
-            res = kima.load_results(model)
+            res = kima.load_results(model, diagnostic=diagnostic)
+
+        res.star = self.star
         return data, model, res
 
     return data, model

{arvi-0.2.11 → arvi-0.3.0}/arvi/simbad_wrapper.py

@@ -204,7 +204,7 @@ class simbad:
         try:
             table2 = run_query(query=BV_QUERY.format(star=self.star))
             if _debug:
-                print('table2:', table2)
+                print('table2:\n', table2)
             cols, values = parse_table1(table2, cols, values)
         except IndexError:
             self.B = self.V = np.nan
@@ -228,6 +228,14 @@ class simbad:
                 setattr(self, '_' + filter_name, ufloat(float(mag), float(mag_err)))
             except ValueError:
                 setattr(self, '_' + filter_name, float(mag))
+            
+            # substitute missing V magnitude
+            if filter_name == 'V' and values[cols.index('V')] == '':
+                values[cols.index('V')] = mag
+            # substitute missing B magnitude
+            if filter_name == 'B' and values[cols.index('B')] == '':
+                values[cols.index('B')] = mag
+
 
         # measurements table
         table5 = run_query(query=MEAS_QUERY.format(star=self.star))
@@ -285,8 +293,12 @@ class simbad:
         except IndexError:
             if self.sp_type == '':
                 if len(self.measurements.teff) > 0:
-                    self.teff = int(np.mean(self.measurements.teff))
-                    self.sp_type = teff_to_sptype(self.teff)
+                    try:
+                        self.teff = int(np.mean(self.measurements.teff))
+                        self.sp_type = teff_to_sptype(self.teff)
+                    except ValueError:
+                        self.teff = np.nan
+                        self.sp_type = ''
             elif self.sp_type[:2] in EFFECTIVE_TEMPERATURES:
                 self.teff = EFFECTIVE_TEMPERATURES[self.sp_type[:2]]
 

{arvi-0.2.11 → arvi-0.3.0}/arvi/timeseries.py

@@ -145,6 +145,7 @@ class RV(ISSUES, REPORTS):
         if self.verbose:
             logger.info('querying Simbad...')
 
+        # TODO: removing the 'A' might not be a good idea 
         # complicated way to query Simbad with self.__star__ or, if that
         # fails, try after removing a trailing 'A'
         for target in set([self.__star__, self.__star__.replace('A', '')]):
@@ -590,9 +591,12 @@ class RV(ISSUES, REPORTS):
         """ Total time span of the (masked) observations """
         return np.ptp(self.mtime)
 
-    def _index_from_instrument_index(self, index, instrument):
+    def _index_from_instrument_index(self, index, instrument, masked=True):
         ind = np.where(self.instrument_array == instrument)[0]
-        return ind[getattr(self, instrument).mask][index]
+        if masked:
+            return ind[getattr(self, instrument).mask][index]
+        else:
+            return ind[index]
 
     # @property
     def _tt(self, f=20) -> np.ndarray:
@@ -651,7 +655,11 @@ class RV(ISSUES, REPORTS):
         return s
 
     @classmethod
-    def from_arrays(cls, star, time, vrad, svrad, inst, **kwargs):
+    def from_arrays(cls, star, time, vrad, svrad, instrument:str, **kwargs):
+        if 'inst' in kwargs:
+            logger.warning('`inst` is deprecated. Use `instrument` instead.')
+            instrument = kwargs.pop('inst')
+
         s = cls(star, _child=True)
         time, vrad, svrad = map(np.atleast_1d, (time, vrad, svrad))
 
@@ -673,8 +681,12 @@ class RV(ISSUES, REPORTS):
         for k, v in kwargs.items():
             setattr(s, k, np.atleast_1d(v))
 
-        s.instruments = [inst]
         s._quantities = np.array(list(kwargs.keys()))
+        _instrument = instrument.replace(' ', '_').replace('-', '_')
+        s.instruments = [_instrument]
+
+        setattr(s, _instrument, deepcopy(s))
+        s._child = False
 
         return s
 
@@ -1039,7 +1051,7 @@ class RV(ISSUES, REPORTS):
             time = np.array([i.bjd for i in CCFs])
             vrad = np.array([i.RV*1e3 for i in CCFs])
             svrad = np.array([i.RVerror*1e3 for i in CCFs])
-            _s = RV.from_arrays(star, time, vrad, svrad, inst=instrument)
+            _s = RV.from_arrays(star, time, vrad, svrad, instrument=instrument)
 
             _quantities = []
 
@@ -1066,9 +1078,13 @@ class RV(ISSUES, REPORTS):
             _s.texp = np.array([i.HDU[0].header['EXPTIME'] for i in CCFs])
             _quantities.append('texp')
 
-            _s.berv = np.array([i.HDU[0].header['HIERARCH ESO QC BERV'] for i in CCFs])
+            try:
+                _s.berv = np.array([i.HDU[0].header['HIERARCH ESO QC BERV'] for i in CCFs])
+            except KeyError:
+                _s.berv = np.full_like(time, np.nan)
             _quantities.append('berv')
 
+
             _s.date_night = np.array([
                 i.HDU[0].header['DATE-OBS'].split('T')[0] for i in CCFs
             ])
@@ -1567,6 +1583,11 @@ class RV(ISSUES, REPORTS):
             condition (ndarray):
                 Boolean array of the same length as the observations
         """
+        condition = np.asarray(condition, dtype=bool)
+        if not np.any(condition):
+            if self.verbose:
+                logger.info('no points to remove')
+            return
         if self.verbose:
             inst = np.unique(self.instrument_array[condition])
             logger.info(f"Removing {condition.sum()} points from instruments {inst}")
@@ -1657,6 +1678,20 @@ class RV(ISSUES, REPORTS):
         for inst in singles:
             self.remove_instrument(inst, strict=True)
 
+    def remove_more_than_n_per_night(self, n=2):
+        """ Remove whenever there are more than `n` observations per night """
+        ind = np.array([], dtype=int)
+        for s in self:
+            # how many observations per night
+            n_night = (np.abs(s.time[:, None] - s.time[None, :]) < 0.5).sum(axis=0)
+            # indices for this instrument
+            ind_s = np.where(n_night >= n)[0]
+            # translate to indices in self
+            ind_self = self._index_from_instrument_index(ind_s, s.instruments[0], masked=False)
+            ind = np.r_[ind, ind_self]
+        if len(ind) > 0:
+            self.remove_point(ind)
+
     def remove_prog_id(self, prog_id):
         """ Remove observations from a given program ID """
         from glob import has_magic
@@ -1695,7 +1730,7 @@ class RV(ISSUES, REPORTS):
             ind = np.where(to_remove)[0]
             self.remove_point(ind)
 
-    def choose_n_points(self, n: int, seed=None, instrument=None):
+    def choose_n_points(self, n: int, instrument=None, seed=None):
         """ Randomly choose `n` observations and mask out the remaining ones
 
         Args:
@@ -1706,21 +1741,21 @@ class RV(ISSUES, REPORTS):
             instrument (str or list, optional):
                 For which instrument to choose points (default is all).
         """
-        instruments = self._check_instrument(instrument)
+        if not self._check_instrument(instrument):
+            return
+        # instruments = self._check_instrument(instrument)
+        mask_for_this_inst = self._instrument_mask(instrument)
         rng = np.random.default_rng(seed=seed)
-        for inst in instruments:
-            # s = getattr(self, inst)
-            mask_for_this_inst = self.obs == self.instruments.index(inst) + 1
-            # only choose if there are more than n points
-            if self.mask[mask_for_this_inst].sum() > n:
-                if self.verbose:
-                    logger.info(f'selecting {n} points from {inst}')
-                # indices of points for this instrument which are not masked already
-                available = np.where(self.mask & mask_for_this_inst)[0]
-                # choose n randomly
-                i = rng.choice(available, size=n, replace=False)
-                # mask the others out
-                self.mask[np.setdiff1d(available, i)] = False
+        # only choose if there are more than n points
+        if self.mask[mask_for_this_inst].sum() > n:
+            if self.verbose:
+                logger.info(f'selecting {n} points from {instrument}')
+            # indices of points for this instrument which are not masked already
+            available = np.where(self.mask & mask_for_this_inst)[0]
+            # choose n randomly
+            i = rng.choice(available, size=n, replace=False)
+            # mask the others out
+            self.mask[np.setdiff1d(available, i)] = False
         self._propagate_mask_changes()
 
 
@@ -1924,10 +1959,14 @@ class RV(ISSUES, REPORTS):
             if np.isnan(d[m]).all():
                 continue
 
-            result = dosigmaclip(d[m], low=sigma, high=sigma)
+            result = dosigmaclip(d[m & self.mask], low=sigma, high=sigma)
             # n = self.vrad[m].size - result.clipped.size
 
-            ind = m & self.mask & ((d < result.lower) | (d > result.upper))
+            # NOTE: result.lower and result.upper are updated values, calculated
+            # *after* the last point has been removed. So the previous solution
+            # getting points outside the range [result.lower, result.upper] is
+            # not correct and we need to use result.clipped instead.
+            ind = m & self.mask & ~np.isin(d, result.clipped)
             n = ind.sum()
 
             if self.verbose and n > 0:
@@ -2020,9 +2059,9 @@ class RV(ISSUES, REPORTS):
 
 
 
-    def bin(self):
+    def bin(self, daily=False):
         """
-        Nightly bin the observations.
+        Bin the observations, nightly by default.
 
         !!! Warning
             This creates and returns a new object and does not modify self.
@@ -2033,6 +2072,8 @@ class RV(ISSUES, REPORTS):
         # store original object
         snew._unbinned = deepcopy(self)
 
+        time_offset = 0.5 if daily else 0.0
+
         all_bad_quantities = []
 
         for inst in snew.instruments:
@@ -2046,7 +2087,8 @@ class RV(ISSUES, REPORTS):
             if s.mtime.size == 0:
                 continue
 
-            tb, vb, svb = binRV(s.mtime, s.mvrad, s.msvrad)
+            tb, vb, svb = binRV(s.mtime + time_offset, s.mvrad, s.msvrad)
+            tb -= time_offset
             s.vrad = vb
             s.svrad = svb
 
@@ -2057,14 +2099,14 @@ class RV(ISSUES, REPORTS):
 
                 # treat date_night specially, basically doing a group-by
                 if q == 'date_night':
-                    inds = binRV(s.mtime, None, None, binning_indices=True)
+                    inds = binRV(s.mtime + time_offset, None, None, binning_indices=True)
                     setattr(s, q, Q[s.mask][inds])
                     continue
 
                 # treat ccf_mask specially, doing a 'unique' bin
                 if q == 'ccf_mask':
                     ccf_mask = getattr(s, q)[s.mask]
-                    setattr(s, q, bin_ccf_mask(s.mtime, ccf_mask))
+                    setattr(s, q, bin_ccf_mask(s.mtime + time_offset, ccf_mask))
                     continue
 
                 if Q.dtype != np.float64:
@@ -2079,12 +2121,14 @@ class RV(ISSUES, REPORTS):
                 elif q + '_err' in s._quantities:
                     Qerr = getattr(s, q + '_err')
                     if (Qerr == 0.0).all(): # if all errors are NaN, don't use them
-                        _, yb = binRV(s.mtime, Q[s.mask], stat='mean', tstat='mean')
+                        _, yb = binRV(s.mtime + time_offset, Q[s.mask],
+                                      stat='mean', tstat='mean')
                     else:
                         if (Qerr <= 0.0).any(): # if any error is <= 0, set it to NaN
                             Qerr[Qerr <= 0.0] = np.nan
 
-                        _, yb, eb = binRV(s.mtime, Q[s.mask], Qerr[s.mask], remove_nans=False)
+                        _, yb, eb = binRV(s.mtime + time_offset, Q[s.mask], Qerr[s.mask],
+                                          remove_nans=False)
                         setattr(s, q + '_err', eb)
 
                     setattr(s, q, yb)
@@ -2093,7 +2137,7 @@ class RV(ISSUES, REPORTS):
                     with warnings.catch_warnings():
                         warnings.filterwarnings('ignore', category=RuntimeWarning)
                         try:
-                            _, yb = binRV(s.mtime, Q[s.mask],
+                            _, yb = binRV(s.mtime + time_offset, Q[s.mask],
                                         stat=np.nanmean, tstat=np.nanmean)
                             setattr(s, q, yb)
                         except TypeError:
@@ -2395,7 +2439,7 @@ class RV(ISSUES, REPORTS):
         if new_units not in possible:
             msg = f"new_units must be one of 'm/s', 'km/s', 'ms', 'kms', got '{new_units}'"
             raise ValueError(msg)
-        
+
         new_units = possible[new_units]
         if new_units == self.units:
             return
@@ -2403,11 +2447,14 @@ class RV(ISSUES, REPORTS):
         if self.verbose:
             logger.info(f"changing units from {self.units} to {new_units}")
 
-        if new_units == 'm/s' and self.units == 'km/s':
+        if new_units == 'm/s' and self.units in ('km/s', 'kms'):
             factor = 1e3
-        elif new_units == 'km/s' and self.units == 'm/s':
+        elif new_units == 'km/s' and self.units in ('m/s', 'ms'):
             factor = 1e-3
-        
+        else:
+            logger.warning(f"no known conversion from {self.units} to {new_units}")
+            return
+
         for inst in self.instruments:
             s = getattr(self, inst)
             s.vrad *= factor
@@ -2469,6 +2516,10 @@ class RV(ISSUES, REPORTS):
             by_last_observation (bool, optional):
                 Sort by last observation date
         """
+        if self.N == 0:
+            if self.verbose:
+                logger.warning("no observations to sort")
+            return
         if by_last_observation:
             by_first_observation = False
         if by_first_observation:

{arvi-0.2.11 → arvi-0.3.0/arvi.egg-info}/PKG-INFO

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