arvi 0.1.18__py3-none-any.whl → 0.1.19__py3-none-any.whl

arvi/__init__.py

@@ -1,7 +1,16 @@
 __all__ = ['RV']
 
+from importlib.metadata import version, PackageNotFoundError
+
+from .config import config
 from .timeseries import RV
 
+try:
+    __version__ = version("arvi")
+except PackageNotFoundError:
+    # package is not installed
+    pass
+
 ## OLD
 # # the __getattr__ function is always called twice, so we need this
 # # to only build and return the RV object on the second time

arvi/ariadne_wrapper.py

@@ -2,6 +2,9 @@ import os
 import sys
 from matplotlib import pyplot as plt
 
+from .utils import stdout_disabled, all_logging_disabled
+from .setup_logger import logger
+
 try:
     from astroARIADNE.star import Star
     from astroARIADNE.fitter import Fitter

arvi/berv.py

@@ -12,7 +12,7 @@ from astropy.timeseries import LombScargle
 from tqdm import tqdm
 
 from .setup_logger import logger
-from . import config
+from .config import config
 
 
 def correct_rvs(self, simple=False, H=None, save_files=False, plot=True):
@@ -349,7 +349,6 @@ def BERV(self, H=None, use_gaia_meassurements=False, plx=None,
         axs[1].plot(bjd, diff, 'k.', label=label)
         axs[1].axhline(np.mean(diff), ls='--', c='k', alpha=0.1)
 
-        from adjustText import adjust_text
         text = axs[1].text(bjd.max(), diff.min() + 0.1*diff.ptp(), 
                            f'ptp: {diff.ptp()*1e2:.2f} cm/s',
                            ha='right', va='bottom', color='g', alpha=0.8)

arvi/config.py

@@ -1,14 +1,36 @@
-# whether to return self from (some) RV methods
-return_self = False
 
-# whether to check internet connection before querying DACE
-check_internet = False
+def instancer(cls):
+    return cls()
 
-# make all DACE requests without using a .dacerc file
-request_as_public = False
+@instancer
+class config:
+    # configuration values
+    __conf = {
+        # whether to return self from (some) RV methods
+        'return_self': False,
+        # whether to adjust instrument means before gls by default
+        'adjust_means_gls': True,
+        # whether to check internet connection before querying DACE
+        'check_internet': False,
+        # make all DACE requests without using a .dacerc file
+        'request_as_public': False,
+        # username for DACE servers
+        'username': 'desousaj',
+        # debug
+        'debug': False,
+    }
+    # all, for now
+    __setters = list(__conf.keys())
 
-# whether to adjust instrument means before gls by default
-adjust_means_gls = True
+    def __getattr__(self, name):
+        if name in ('__custom_documentations__', ):
+            # return {'return_self': 'help!'}
+            return {}
 
-# debug
-debug = False
+        return self.__conf[name]
+
+    def __setattr__(self, name, value):
+        if name in config.__setters:
+            self.__conf[name] = value
+        else:
+            raise NameError(f"unknown configuration name '{name}'")

arvi/dace_wrapper.py

@@ -10,8 +10,8 @@ from .utils import create_directory, all_logging_disabled, stdout_disabled, tqdm
 
 
 def load_spectroscopy() -> SpectroscopyClass:
-    from .config import request_as_public
-    if request_as_public:
+    from .config import config
+    if config.request_as_public:
         with all_logging_disabled():
             dace = DaceClass(dace_rc_config_path='none')
         return SpectroscopyClass(dace_instance=dace)
@@ -123,7 +123,7 @@ def get_observations_from_instrument(star, instrument, main_id=None):
 
     Spectroscopy = load_spectroscopy()
     filters = {
-        "ins_name": {"contains": [instrument]}, 
+        "ins_name": {"contains": [instrument]},
         "obj_id_daceid": {"contains": [dace_id]}
     }
     with stdout_disabled(), all_logging_disabled():
@@ -251,9 +251,9 @@ def get_observations(star, instrument=None, main_id=None, verbose=True):
     # (i.e. ensure that 3.x.x > 3.5)
     from re import match
     def cmp(a, b):
-        if a[0] in ('3.5', '3.5 EGGS') and match(r'3.\d.\d', b[0]):
+        if a[0] in ('3.5', '3.5 EGGS') or 'EGGS' in a[0] and match(r'3.\d.\d', b[0]):
             return -1
-        if b[0] in ('3.5', '3.5 EGGS') and match(r'3.\d.\d', a[0]):
+        if b[0] in ('3.5', '3.5 EGGS') or 'EGGS' in b[0] and match(r'3.\d.\d', a[0]):
             return 1
 
         if a[0] == b[0]:
@@ -411,12 +411,12 @@ def do_download_filetype(type, raw_files, output_directory, clobber=False,
 
     if verbose:
         if chunk_size < n:
-            msg = f"Downloading {n} {type}s "
+            msg = f"downloading {n} {type}s "
             msg += f"(in chunks of {chunk_size}) "
             msg += f"into '{output_directory}'..."
             logger.info(msg)
         else:
-            msg = f"Downloading {n} {type}s into '{output_directory}'..."
+            msg = f"downloading {n} {type}s into '{output_directory}'..."
             logger.info(msg)
 
     iterator = [raw_files[i:i + chunk_size] for i in range(0, n, chunk_size)]
@@ -424,7 +424,7 @@ def do_download_filetype(type, raw_files, output_directory, clobber=False,
         download(files, type, output_directory)
         extract_fits(output_directory)
 
-    logger.info('Extracted .fits files')
+    logger.info('extracted .fits files')
 
 
 # def do_download_s1d(raw_files, output_directory, clobber=False, verbose=True):

arvi/gaia_wrapper.py

@@ -30,6 +30,7 @@ gaia_source.source_id = {id}
 """
 
 translate = {
+    'Proxima': '5853498713190525696',
     'LS II +14 13': '4318465066420528000',
 }
 
@@ -38,7 +39,7 @@ def run_query(query):
     url = 'https://gea.esac.esa.int/tap-server/tap/sync'
     data = dict(query=query, request='doQuery', lang='ADQL', format='csv')
     try:
-        response = requests.post(url, data=data, timeout=5)
+        response = requests.post(url, data=data, timeout=2)
     except requests.ReadTimeout as err:
         raise IndexError(err)
     except requests.ConnectionError as err:
@@ -85,6 +86,8 @@ class gaia:
         try:
             if star in translate:
                 table = run_query(query=QUERY_ID.format(id=translate[star]))
+            elif hasattr(simbad, 'gaia_id'):
+                table = run_query(query=QUERY_ID.format(id=simbad.gaia_id))
             else:
                 table = run_query(query=QUERY.format(**args))
             results = parse_csv(table)[0]

arvi/instrument_specific.py

@@ -103,11 +103,10 @@ def ADC_issues(self, mask=True, plot=True, check_headers=False):
     """
     instruments = self._check_instrument('ESPRESSO')
     
-    if len(instruments) < 1:
+    if instruments is None:
         if self.verbose:
-            logger.error(f"no data from ESPRESSO")
-            logger.info(f'available: {self.instruments}')
-    
+            logger.error(f"ADC_issues: no data from ESPRESSO")
+        return
 
     affected_file_roots = ESPRESSO_ADC_issues()
     file_roots = [os.path.basename(f).replace('.fits', '') for f in self.raw_file]
@@ -149,10 +148,10 @@ def blue_cryostat_issues(self, mask=True, plot=True):
     """
     instruments = self._check_instrument('ESPRESSO')
     
-    if len(instruments) < 1:
+    if instruments is None:
         if self.verbose:
-            logger.error(f"no data from ESPRESSO")
-            logger.info(f'available: {self.instruments}')
+            logger.error(f"blue_cryostat_issues: no data from ESPRESSO")
+        return
 
     affected_file_roots = ESPRESSO_cryostat_issues()
     file_roots = [os.path.basename(f).replace('.fits', '') for f in self.raw_file]
@@ -230,16 +229,18 @@ def known_issues(self, mask=True, plot=False, **kwargs):
     """
     try:
         adc = ADC_issues(self, mask, plot, **kwargs)
-    except IndexError as e:
+    except IndexError:
         # logger.error(e)
         logger.error('are the data binned? cannot proceed to mask these points...')
 
     try:
         cryostat = blue_cryostat_issues(self, mask, plot)
-    except IndexError as e:
+    except IndexError:
         # logger.error(e)
         logger.error('are the data binned? cannot proceed to mask these points...')
 
+    if adc is None and cryostat is None:
+        return
     try:
         return adc | cryostat
     except UnboundLocalError:

arvi/kima_wrapper.py

@@ -0,0 +1,74 @@
+import os
+import numpy as np
+
+from .setup_logger import logger
+
+try:
+    import kima
+    from kima.pykima.utils import chdir
+    from kima import distributions
+    from kima import RVData, RVmodel
+    kima_available = True
+except ImportError:
+    kima_available = False
+
+
+def try_to_guess_prior(model, prior):
+    if 'jitter' in prior:
+        return 'Jprior'
+    if 'vsys' in prior:
+        return 'Cprior'
+    return None
+
+
+def run_kima(self, run=False, load=False, run_directory=None, priors={}, **kwargs):
+    if not kima_available:
+        raise ImportError('kima not available, please install with `pip install kima`')
+
+    time = [getattr(self, inst).mtime for inst in self.instruments]
+    vrad = [getattr(self, inst).mvrad for inst in self.instruments]
+    err = [getattr(self, inst).msvrad for inst in self.instruments]
+    data = RVData(time, vrad, err, instruments=self.instruments)
+
+    fix = kwargs.pop('fix', False)
+    npmax = kwargs.pop('npmax', 1)
+    model = RVmodel(fix=fix, npmax=npmax, data=data)
+
+    model.trend = kwargs.pop('trend', False)
+    model.degree = kwargs.pop('degree', 0)
+
+    model.studentt = kwargs.pop('studentt', False)
+    model.enforce_stability = kwargs.pop('enforce_stability', False)
+    model.star_mass = kwargs.pop('star_mass', 1.0)
+
+    for k, v in priors.items():
+        try:
+            if 'conditional' in k:
+                setattr(model.conditional, k.replace('conditional.', ''), v)
+            else:
+                setattr(model, k, v)
+
+        except AttributeError:
+            msg = f'`RVmodel` has no attribute `{k}`, '
+            if guess := try_to_guess_prior(model, k):
+                msg += f'did you mean `{guess}`?'
+            logger.warning(msg)
+            return
+
+    if run:
+        if run_directory is None:
+            run_directory = os.getcwd()
+        
+        # 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]]
+
+        with chdir(run_directory):
+            kima.run(model, **kwargs)
+        
+        if load:
+            res = kima.load_results(model)
+            return data, model, res
+
+    return data, model

arvi/reports.py

@@ -27,6 +27,29 @@ 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

arvi/simbad_wrapper.py

@@ -3,6 +3,8 @@ import requests
 
 import pysweetcat
 
+from .translations import translate
+
 DATA_PATH = os.path.dirname(__file__)
 DATA_PATH = os.path.join(DATA_PATH, 'data')
 
@@ -98,7 +100,7 @@ class simbad:
         """
         from astropy.coordinates import SkyCoord
 
-        self.star = star
+        self.star = translate(star, ngc=True, ic=True)
 
         if 'kobe' in self.star.lower():
             fname = os.path.join(DATA_PATH, 'KOBE-translate.csv')
@@ -117,13 +119,13 @@ class simbad:
         # self.oid = str(oid.split()[-1])
 
         try:
-            table1 = run_query(query=QUERY.format(star=star))
+            table1 = run_query(query=QUERY.format(star=self.star))
             cols, values = parse_table(table1)
 
-            table2 = run_query(query=BV_QUERY.format(star=star))
+            table2 = run_query(query=BV_QUERY.format(star=self.star))
             cols, values = parse_table(table2, cols, values)
 
-            table3 = run_query(query=IDS_QUERY.format(star=star))
+            table3 = run_query(query=IDS_QUERY.format(star=self.star))
             line = table3.splitlines()[2]
             self.ids = line.replace('"', '').replace('    ', ' ').replace('   ', ' ').replace('  ', ' ').split('|')
         except IndexError: