#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
:py:mod:`utils.py` - General utils
----------------------------------
General utility functions called from various parts of the code.
'''
from __future__ import division, print_function, absolute_import, \
unicode_literals
import numpy as np
import os
import sys
import traceback
import pdb
import logging
from matplotlib.ticker import FuncFormatter
log = logging.getLogger(__name__)
#: Marks a pixel into which a row was collapsed.
#: Note that ``AP_COLLAPSED_PIXEL & 1 = 1``
AP_COLLAPSED_PIXEL = 9
#: Marks a saturated pixel that was masked out.
#: Note that ``AP_SATURATED_PIXEL & 1 = 0``
AP_SATURATED_PIXEL = 8
class FunctionWrapper(object):
'''
A simple function wrapper class. Stores :py:obj:`args` and
:py:obj:`kwargs` and allows an arbitrary function to be called with a
single parameter :py:obj:`x`
'''
def __init__(self, f, *args, **kwargs):
'''
'''
self.f = f
self.args = args
self.kwargs = kwargs
def __call__(self, x):
'''
'''
return self.f(x, *self.args, **self.kwargs)
class NoPILFilter(logging.Filter):
'''
The :py:obj:`PIL` image module has a nasty habit of sending all sorts of
unintelligible information to the logger. We filter that out here.
'''
def filter(self, record):
return not record.name == 'PIL.PngImagePlugin'
def InitLog(file_name=None, log_level=logging.DEBUG,
screen_level=logging.CRITICAL, pdb=False):
'''
A little routine to initialize the logging functionality.
:param str file_name: The name of the file to log to. \
Default :py:obj:`None` (set internally by :py:mod:`everest`)
:param int log_level: The file logging level (0-50). Default 10 (debug)
:param int screen_level: The screen logging level (0-50). \
Default 50 (critical)
'''
# Initialize the logging
root = logging.getLogger()
root.handlers = []
root.setLevel(logging.DEBUG)
# File handler
if file_name is not None:
if not os.path.exists(os.path.dirname(file_name)):
os.makedirs(os.path.dirname(file_name))
fh = logging.FileHandler(file_name)
fh.setLevel(log_level)
fh_formatter = logging.Formatter(
"%(asctime)s %(levelname)-5s [%(name)s.%(funcName)s()]: %(message)s",
datefmt="%m/%d/%y %H:%M:%S")
fh.setFormatter(fh_formatter)
fh.addFilter(NoPILFilter())
root.addHandler(fh)
# Screen handler
sh = logging.StreamHandler(sys.stdout)
if pdb:
sh.setLevel(logging.DEBUG)
else:
sh.setLevel(screen_level)
sh_formatter = logging.Formatter(
"%(levelname)-5s [%(name)s.%(funcName)s()]: %(message)s")
sh.setFormatter(sh_formatter)
sh.addFilter(NoPILFilter())
root.addHandler(sh)
# Set exception hook
if pdb:
sys.excepthook = ExceptionHookPDB
else:
sys.excepthook = ExceptionHook
def ExceptionHook(exctype, value, tb):
'''
A custom exception handler that logs errors to file.
'''
for line in traceback.format_exception_only(exctype, value):
log.error(line.replace('\n', ''))
for line in traceback.format_tb(tb):
log.error(line.replace('\n', ''))
sys.__excepthook__(exctype, value, tb)
def ExceptionHookPDB(exctype, value, tb):
'''
A custom exception handler, with :py:obj:`pdb` post-mortem for debugging.
'''
for line in traceback.format_exception_only(exctype, value):
log.error(line.replace('\n', ''))
for line in traceback.format_tb(tb):
log.error(line.replace('\n', ''))
sys.__excepthook__(exctype, value, tb)
pdb.pm()
def _float(s):
'''
A silly but useful wrapper around :py:obj:`float()` that
returns :py:obj:`NaN` on error
:param s: The object to be converted to a float
'''
try:
res = float(s)
except:
res = np.nan
return res
def sort_like(l, col1, col2):
'''
Sorts the list :py:obj:`l` by comparing :py:obj:`col2` to :py:obj:`col1`.
Specifically, finds the indices :py:obj:`i` such that ``col2[i] = col1``
and returns ``l[i]``. This is useful when comparing the CDPP values of
catalogs generated by different pipelines. The
target IDs are all the same, but won't necessarily be in the same order.
This allows :py:obj:`everest` to sort the CDPP arrays so that the
targets match.
:param array_like l: The list or array to sort
:param array_like col1: A list or array (same length as :py:obj:`l`)
:param array_like col2: A second list or array containing the same \
elements as :py:obj:`col1` but in a different order
'''
s = np.zeros_like(col1) * np.nan
for i, c in enumerate(col1):
j = np.argmax(col2 == c)
if j == 0:
if col2[0] != c:
continue
s[i] = l[j]
return s
class DataContainer(object):
'''
A generic data container. Nothing fancy here.
'''
def __init__(self):
'''
'''
self.ID = None
self.campaign = None
self.cadn = None
self.time = None
self.fpix = None
self.fpix_err = None
self.nanmask = None
self.badmask = None
self.aperture = None
self.aperture_name = None
self.apertures = None
self.quality = None
self.Xpos = None
self.Ypos = None
self.mag = None
self.pixel_images = None
self.nearby = None
self.hires = None
self.saturated = None
self.meta = None
class Formatter(object):
'''
Custom function formatters for displaying ticks on plots.
'''
#: Integer formatter for a flux axis
Flux = FuncFormatter(lambda x, p: '%6d' % x)
#: Integer formatter for a CDPP axis
CDPP = FuncFormatter(lambda x, p: '%3d' % x)
#: Floating point formatter for a CDPP axis (1 digit after decimal)
CDPP1F = FuncFormatter(lambda x, p: '%.1f' % x)
#: Floating point formatter for a CDPP axis (2 digits after decimal)
CDPP2F = FuncFormatter(lambda x, p: '%.2f' % x)
#: Integer formatter for chunk number
Chunk = FuncFormatter(lambda x, p: '%2d' % x)
def prange(*x):
'''
Progress bar range with `tqdm`
'''
try:
root = logging.getLogger()
if len(root.handlers):
for h in root.handlers:
if (type(h) is logging.StreamHandler) and \
(h.level != logging.CRITICAL):
from tqdm import tqdm
return tqdm(range(*x))
return range(*x)
else:
from tqdm import tqdm
return tqdm(range(*x))
except ImportError:
return range(*x)
