sdss-almanac 0.2.1__py3-none-any.whl

almanac/io.py

@@ -0,0 +1,320 @@
+import h5py as h5
+import numpy as np
+from tqdm import tqdm
+from typing import List, Literal, Dict, Any, Tuple, Union, get_origin, get_args
+from pydantic import BaseModel
+from pydantic.fields import (FieldInfo, ComputedFieldInfo)
+from pydantic_core import PydanticUndefined
+import datetime
+from enum import Enum
+
+from almanac.data_models import Exposure
+
+def write_almanac(
+    output: str,
+    results: List[Tuple[str, int, List[Exposure], Dict[str, List[Any]]]],
+    fibers: bool = False,
+    verbose: bool = False,
+    compression: bool = True
+):
+    """
+    Write the results of an Almanac query to an HDF5 file.
+
+    :param output:
+        Path to the output HDF5 file.
+
+    :param results:
+        List of tuples containing (observatory, mjd, exposures, sequences).
+        - observatory: str, e.g., "apo" or "lco"
+        - mjd: int, Modified Julian Date
+        - exposures: List[Exposure], list of Exposure models
+        - sequences: Dict[str, List[Any]], dictionary of sequences by image type
+
+    :param fibers:
+        Whether to include fiber data in the output.
+
+    :param verbose:
+        Whether to print progress information.
+
+    :param compression:
+        Compression algorithm to use for datasets. If True, uses 'gzip'.
+    """
+
+    kwds = dict(fibers=fibers, verbose=verbose, compression=compression)
+    with h5.File(output, "a") as fp:
+        for args in sorted(results, key=lambda x: (x[0], x[1])):
+            update(fp, *args, **kwds)
+
+def update(
+    fp,
+    observatory,
+    mjd,
+    exposures,
+    sequences,
+    fibers: bool = False,
+    verbose: bool = False,
+    compression: Union[bool, str] = True
+):
+    _print = print if verbose else lambda *args, **kwargs: None
+
+    group = get_or_create_group(fp, f"{observatory}/{mjd}")
+    _print(f"\t{observatory}/{mjd}")
+
+    delete_hdf5_entry(group, "exposures")
+    write_models_to_hdf5_group(
+        exposures,
+        group.create_group("exposures", track_order=True)
+    )
+
+    _print(f"\t{observatory}/{mjd}/exposures")
+
+    if len(sequences) > 0:
+        delete_hdf5_entry(group, "sequences")
+        sequences_group = group.create_group("sequences")
+        for image_type, entries in sequences.items():
+            sequences_group.create_dataset(image_type, data=np.array(entries))
+            _print(f"\t{observatory}/{mjd}/sequences/{image_type}")
+
+    if fibers:
+        fibers_group = get_or_create_group(fp, f"{observatory}/{mjd}/fibers")
+        done = set()
+        for exposure in exposures:
+            if not exposure.targets:
+                continue
+
+            reference_id_string = str(
+                exposure.config_id if exposure.fps else exposure.plate_id
+            )
+            if reference_id_string in done:
+                continue
+
+            delete_hdf5_entry(fibers_group, reference_id_string)
+            write_models_to_hdf5_group(
+                exposure.targets,
+                fibers_group.create_group(reference_id_string, track_order=True)
+            )
+            done.add(reference_id_string)
+            _print(f"\t{observatory}/{mjd}/fibers/{reference_id_string}")
+
+
+
+def get_or_create_group(fp, group_name):
+    try:
+        group = fp[group_name]
+    except KeyError:
+        group = fp.create_group(group_name)
+    finally:
+        return group
+
+
+def delete_hdf5_entry(fp, group_name):
+    try:
+        del fp[group_name]
+    except KeyError:
+        pass
+
+
+def get_hdf5_dtype(pydantic_type, sample_value=None):
+    """
+    Map Pydantic field types to appropriate HDF5/NumPy dtypes.
+
+    Args:
+        pydantic_type: The Pydantic field type annotation
+        sample_value: A sample value to help determine string lengths, etc.
+
+    Returns:
+        Appropriate NumPy dtype for HDF5
+    """
+    # Handle Union types (including Optional)
+    if get_origin(pydantic_type) is Union:
+        # For Optional[T] (Union[T, None]), use the non-None type
+        args = get_args(pydantic_type)
+        non_none_types = [arg for arg in args if arg is not type(None)]
+        if non_none_types:
+            pydantic_type = non_none_types[0]
+
+    # Handle List types
+    if get_origin(pydantic_type) is list:
+        inner_type = get_args(pydantic_type)[0]
+        return get_hdf5_dtype(inner_type, sample_value)
+
+    # Basic type mappings
+    type_mapping = {
+        np.int64: np.int64,
+        int: np.int64,
+        float: np.float64,
+        bool: np.bool_,
+        str: 'S',  # Will be handled specially for variable length
+        bytes: np.bytes_,
+        datetime.datetime: 'S19',  # ISO format YYYY-MM-DDTHH:MM:SS
+        datetime.date: 'S10',      # ISO format YYYY-MM-DD
+        datetime.time: 'S8',       # Format HH:MM:SS
+    }
+
+    # Direct type mapping
+    if pydantic_type in type_mapping:
+        dtype = type_mapping[pydantic_type]
+
+        # Handle string length determination
+        if dtype == 'S' and sample_value is not None:
+            if isinstance(sample_value, (list, tuple)):
+                max_len = max(len(str(v)) for v in sample_value) if sample_value else 1
+            else:
+                max_len = len(str(sample_value)) if sample_value else 1
+            return f'S{max_len}'
+        elif dtype == 'S':
+            return 'S100'  # Default string length
+
+        return dtype
+
+    # Handle Enum types
+    if isinstance(pydantic_type, type) and issubclass(pydantic_type, Enum):
+        # Store enum values as strings
+        if sample_value is not None:
+            if isinstance(sample_value, (list, tuple)):
+                max_len = max(len(str(v.value)) for v in sample_value) if sample_value else 1
+            else:
+                max_len = len(str(sample_value.value)) if sample_value else 1
+            return f'S{max_len}'
+        return 'S50'
+
+    # Handle Literal types
+    if get_origin(pydantic_type) is Literal:
+        args = get_args(pydantic_type)
+        if all(isinstance(arg, str) for arg in args):
+            max_len = max(len(arg) for arg in args) if args else 1
+            return f'S{max_len}'
+        elif all(isinstance(arg, int) for arg in args):
+            return np.int64
+        elif all(isinstance(arg, float) for arg in args):
+            return np.float64
+        elif all(isinstance(arg, bool) for arg in args):
+            return np.bool_
+
+    # Default fallback - try to convert to string
+    return 'S100'
+
+def extract_field_data(models: List[BaseModel], field_name: str) -> List[Any]:
+    """Extract data for a specific field from all models."""
+    return [getattr(model, field_name) for model in models]
+
+def convert_value_for_hdf5(value, target_dtype):
+    """Convert a Python value to be compatible with HDF5 storage."""
+    if value is None:
+        if target_dtype.char == 'S':
+            return b''
+        elif target_dtype == np.bool_:
+            return False
+        else:
+            return 0  # or np.nan for float types
+
+    if isinstance(value, Enum):
+        return str(value.value).encode('utf-8') if target_dtype.char == 'S' else str(value.value)
+
+    if isinstance(value, datetime.datetime):
+        return value.isoformat().encode('utf-8')
+
+    if isinstance(value, datetime.date):
+        return value.isoformat().encode('utf-8')
+
+    if isinstance(value, datetime.time):
+        return value.isoformat().encode('utf-8')
+
+    if isinstance(value, str) and target_dtype.char == 'S':
+        return value.encode('utf-8')
+
+    if isinstance(value, list):
+        # Handle lists by converting each element
+        return [convert_value_for_hdf5(v, target_dtype) for v in value]
+
+    return value
+
+
+def write_models_to_hdf5_group(
+    models: List[BaseModel],
+    hdf5_group: h5.Group,
+    chunk_size: int = 1000,
+    compression: str = None
+):
+    """
+    Write a list of Pydantic models to an HDF5 group as separate datasets per field.
+
+    Args:
+        models: List of Pydantic model instances (all same type)
+        hdf5_group: HDF5 group to write datasets to
+        chunk_size: Chunk size for HDF5 datasets (for performance)
+        compression: Compression algorithm ('gzip', 'lzf', 'szip', None)
+    """
+    model_type = type(models[0])
+
+    fields = { **model_type.model_fields, **model_type.model_computed_fields }
+
+    data = {
+        field_name: extract_field_data(models, field_name) for field_name in fields.keys()
+    }
+    return _write_models_to_hdf5_group(
+        fields,
+        data,
+        hdf5_group,
+        chunk_size=chunk_size,
+        compression=compression
+    )
+
+
+def _write_models_to_hdf5_group(
+    fields,
+    data,
+    hdf5_group,
+    chunk_size: int = 1000,
+    compression: str = None
+):
+    num_records = None
+
+    for field_name, field_spec in fields.items():
+
+        # Extract data for this field from all models
+        field_data = data[field_name]
+        if num_records is None:
+            num_records = len(field_data)
+
+
+        # Determine the appropriate HDF5 dtype
+        if isinstance(field_spec, FieldInfo):
+            field_type = field_spec.annotation
+        else:
+            field_type = field_spec.return_type
+
+        hdf5_dtype = get_hdf5_dtype(field_type, field_data)
+
+        # Convert values for HDF5 storage
+        converted_data = [convert_value_for_hdf5(value, np.dtype(hdf5_dtype))
+                         for value in field_data]
+
+        # Handle variable-length data (like lists)
+        if any(isinstance(value, list) for value in converted_data):
+            # Create variable-length dataset
+            dt = h5py.special_dtype(vlen=np.dtype(hdf5_dtype))
+            dataset = hdf5_group.create_dataset(
+                field_name,
+                (num_records,),
+                dtype=dt,
+                chunks=True if num_records > chunk_size else None,
+                compression=compression if num_records > chunk_size else None
+            )
+            dataset[:] = converted_data
+        else:
+            # Create regular dataset
+            np_array = np.array(converted_data, dtype=hdf5_dtype)
+
+            chunks = (min(chunk_size, num_records),) if num_records > chunk_size else None
+            compression_setting = compression if num_records > chunk_size else None
+
+            dataset = hdf5_group.create_dataset(
+                field_name,
+                data=np_array,
+                chunks=chunks,
+                compression=compression_setting
+            )
+
+        # Add description, even if it is empty string.
+        dataset.attrs["description"] = field_spec.description or ""

almanac/logger.py

@@ -0,0 +1,27 @@
+import logging
+import colorlog
+
+from almanac import config
+
+def get_formatter():
+    return colorlog.ColoredFormatter(
+        "%(log_color)s%(asctime)s [%(levelname)s] %(message)s",
+        log_colors={
+            "DEBUG": "cyan",
+            "INFO": "white",
+            "WARNING": "yellow",
+            "ERROR": "red",
+            "CRITICAL": "bold_red",
+        },
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+def get_logger():
+    handler = colorlog.StreamHandler()
+    logger = logging.getLogger()
+    logger.setLevel(int(config.logging_level))
+    logger.addHandler(handler)
+    handler.setFormatter(get_formatter())
+    return logger
+
+logger = get_logger()

almanac/qa.py

@@ -0,0 +1,24 @@
+from astropy.table import Table
+from importlib import resources
+
+def get_bad_exposures():
+    with resources.as_file(resources.files("almanac.etc") / "bad_exposures.csv") as fp:
+        t = Table.read(fp)
+        # We want a lookup table for (observatory, mjd, exposure)
+        t["exposure"] = t["exposure"].filled(-1)
+        d = {}
+        for row in t:
+            key = (str(row["observatory"]), int(row["mjd"]), int(row["exposure"]))
+            try:
+                plate = str(row["plate"])
+            except:
+                plate = -999
+            d[key] = {
+                "image_type": str(row["image_type"]),
+                "plate": plate,
+                "notes": str(row["notes"])
+            }
+        return d
+
+
+lookup_bad_exposures = get_bad_exposures()

almanac/stash/plugmap_models.py

@@ -0,0 +1,165 @@
+from enum import Enum
+from typing import List, Literal, Optional
+from pydantic import BaseModel, Field
+
+
+
+
+class PluggedHole(BaseModel):
+    """
+    Frozen data class representing a plug map object.
+
+    Corresponds to the PLUGMAPOBJ struct from the C typedef.
+    """
+
+    class Config:
+        frozen = True
+
+    obj_id: List[int] = Field(alias="objId", min_items=5, max_items=5, description="Object IDs (5 elements)")
+    hole_type: PluggedHoleTypes = Field(alias="holeType", description="Type of hole")
+    ra: float = Field(..., description="Right ascension in degrees")
+    dec: float = Field(..., description="Declination in degrees")
+    mag: List[float] = Field(..., min_items=5, max_items=5, description="Magnitudes (5 elements)")
+    star_l: float = Field(alias="starL", description="Star likelihood")
+    exp_l: float = Field(alias="expL", description="Exponential likelihood")
+    de_vauc_l: float = Field(alias="deVaucL", description="de Vaucouleurs likelihood")
+    obj_type: ObjTypes = Field(alias="objType", description="Object type")
+    x_focal: float = Field(alias="xFocal", description="X focal plane coordinate")
+    y_focal: float = Field(alias="yFocal", description="Y focal plane coordinate")
+    spectrograph_id: int = Field(alias="spectrographId", description="Spectrograph ID")
+    fiber_id: int = Field(alias="fiberId", description="Fiber ID")
+    throughput: int = Field(description="Throughput value")
+    prim_target: int = Field(alias="primTarget", description="Primary target flag")
+    sec_target: int = Field(alias="secTarget", description="Secondary target flag")
+
+
+class PlateHole(BaseModel):
+    """
+    Frozen data class representing the STRUCT1 typedef.
+
+    Contains comprehensive target and observation metadata.
+    """
+
+    class Config:
+        frozen = True
+
+    # Basic target information
+    planned_hole_type: PlannedHoleTypes = Field(alias="holetype", max_length=16, description="Hole type string")
+    target_type: TargetTypes = Field(alias="targettype", max_length=9, description="Target type string")
+    source_type: str = Field(alias="sourcetype", max_length=9, description="Source type string") # TODO
+    target_ra: float = Field(..., description="Target right ascension")
+    target_dec: float = Field(..., description="Target declination")
+    target_ids: str = Field(alias="targetids")
+
+    # Plate and fiber information
+    iplateinput: int = Field(..., description="Plate input ID")
+    pointing: int = Field(..., description="Pointing number")
+    offset: int = Field(..., description="Offset value")
+    planned_fiber_id: int = Field(alias="fiberid", description="Fiber ID")
+    block: int = Field(..., description="Block number")
+    iguide: int = Field(..., description="Guide flag")
+
+    # Focal plane coordinates
+    xf_default: float = Field(..., description="Default X focal coordinate")
+    yf_default: float = Field(..., description="Default Y focal coordinate")
+    xfocal: float = Field(..., description="X focal plane coordinate")
+    yfocal: float = Field(..., description="Y focal plane coordinate")
+
+    # Spectroscopic parameters
+    lambda_eff: float = Field(..., description="Effective wavelength")
+    zoffset: float = Field(..., description="Z offset")
+    bluefiber: int = Field(..., description="Blue fiber flag")
+    chunk: int = Field(..., description="Chunk number")
+    ifinal: int = Field(..., description="Final flag")
+
+    # File information
+    origfile: str = Field(..., max_length=2, description="Original file identifier")
+    fileindx: int = Field(..., description="File index")
+
+    # Physical properties
+    diameter: float = Field(..., description="Diameter")
+    buffer: float = Field(..., description="Buffer size")
+    priority: int = Field(..., description="Target priority")
+
+    # Status flags
+    assigned: int = Field(..., description="Assigned flag")
+    conflicted: int = Field(..., description="Conflicted flag")
+    ranout: int = Field(..., description="Ran out flag")
+    outside: int = Field(..., description="Outside flag")
+
+    # MaNGA specific
+    mangaid: Optional[str] = Field(default="", max_length=12, description="MaNGA ID")
+    ifudesign: Optional[int] = Field(default=-999, description="IFU design ID")
+    ifudesignsize: Optional[int] = Field(default=-999, description="IFU design size")
+    bundle_size: Optional[int] = Field(default=-999, description="Bundle size")
+    fiber_size: Optional[float] = Field(default=-999.0, description="Fiber size")
+    ifuid: Optional[int] = Field(default=-999, description="IFU ID")
+
+    # Photometric data
+    tmass_j: float = Field(..., description="2MASS J magnitude")
+    tmass_h: float = Field(..., description="2MASS H magnitude")
+    tmass_k: float = Field(..., description="2MASS K magnitude")
+    gsc_vmag: float = Field(..., description="GSC V magnitude")
+    tyc_bmag: float = Field(..., description="Tycho B magnitude")
+    tyc_vmag: float = Field(..., description="Tycho V magnitude")
+
+    # Array photometry
+    mfd_mag: List[float] = Field(..., min_items=6, max_items=6, description="MFD magnitudes (6 elements)")
+    usnob_mag: List[float] = Field(..., min_items=5, max_items=5, description="USNO-B magnitudes (5 elements)")
+
+    # Spectral parameters
+    sp_param_source: str = Field(..., max_length=3, description="Spectral parameter source")
+    sp_params: List[float] = Field(..., min_items=4, max_items=4, description="Spectral parameters (4 elements)")
+    sp_param_err: List[float] = Field(..., min_items=4, max_items=4, description="Spectral parameter errors (4 elements)")
+
+    # Target selection flags
+    marvels_target1: int = Field(..., description="MARVELS target flag 1")
+    marvels_target2: int = Field(..., description="MARVELS target flag 2")
+    boss_target1: int = Field(..., description="BOSS target flag 1")
+    boss_target2: int = Field(..., description="BOSS target flag 2")
+    ancillary_target1: int = Field(..., description="Ancillary target flag 1")
+    ancillary_target2: int = Field(..., description="Ancillary target flag 2")
+    segue2_target1: int = Field(..., description="SEGUE-2 target flag 1")
+    segue2_target2: int = Field(..., description="SEGUE-2 target flag 2")
+    segueb_target1: int = Field(..., description="SEGUE-B target flag 1")
+    segueb_target2: int = Field(..., description="SEGUE-B target flag 2")
+    apogee_target1: int = Field(..., description="APOGEE target flag 1")
+    apogee_target2: int = Field(..., description="APOGEE target flag 2")
+    #apogee2_target1: int = Field(..., description="APOGEE-2 target flag 1")
+    #apogee2_target2: int = Field(..., description="APOGEE-2 target flag 2")
+    #apogee2_target3: int = Field(..., description="APOGEE-2 target flag 3")
+    manga_target1: int = Field(..., description="MaNGA target flag 1")
+    manga_target2: int = Field(..., description="MaNGA target flag 2")
+    #manga_target3: int = Field(..., description="MaNGA target flag 3")
+    #eboss_target0: int = Field(..., description="eBOSS target flag 0")
+    #eboss_target1: int = Field(..., description="eBOSS target flag 1")
+    #eboss_target2: int = Field(..., description="eBOSS target flag 2")
+    #eboss_target_id: int = Field(..., description="eBOSS target ID")
+
+    # SDSS imaging data
+    run: int = Field(..., description="SDSS run number")
+    rerun: str = Field(..., max_length=6, description="SDSS rerun")
+    camcol: int = Field(..., description="SDSS camera column")
+    field: int = Field(..., description="SDSS field number")
+    id: int = Field(..., description="Object ID")
+
+    # Photometric measurements (all 5-element arrays for ugriz bands)
+    psfflux: List[float] = Field(..., min_items=5, max_items=5, description="PSF flux (5 bands)")
+    psfflux_ivar: List[float] = Field(..., min_items=5, max_items=5, description="PSF flux inverse variance (5 bands)")
+    fiberflux: List[float] = Field(..., min_items=5, max_items=5, description="Fiber flux (5 bands)")
+    fiberflux_ivar: List[float] = Field(..., min_items=5, max_items=5, description="Fiber flux inverse variance (5 bands)")
+    fiber2flux: List[float] = Field(..., min_items=5, max_items=5, description="Fiber2 flux (5 bands)")
+    fiber2flux_ivar: List[float] = Field(..., min_items=5, max_items=5, description="Fiber2 flux inverse variance (5 bands)")
+    psfmag: List[float] = Field(..., min_items=5, max_items=5, description="PSF magnitude (5 bands)")
+    fibermag: List[float] = Field(..., min_items=5, max_items=5, description="Fiber magnitude (5 bands)")
+    fiber2mag: List[float] = Field(..., min_items=5, max_items=5, description="Fiber2 magnitude (5 bands)")
+    planned_mag: List[float] = Field(..., min_items=5, max_items=5, description="Magnitude (5 bands)")
+
+    # Astrometric data
+    epoch: float = Field(..., description="Epoch of observation")
+    pmra: float = Field(..., description="Proper motion in RA")
+    pmdec: float = Field(..., description="Proper motion in Dec")
+
+
+class PluggedTarget(PlateHole, PluggedHole):
+    pass

almanac/utils.py

@@ -0,0 +1,141 @@
+import numpy as np
+from time import time
+from datetime import datetime
+from itertools import cycle, groupby
+from typing import Tuple, Union, Optional, List, Dict, Any
+from astropy.table import Table
+from astropy.time import Time
+from astropy.io.registry import register_identifier, register_reader, register_writer
+from pydl.pydlutils.yanny import is_yanny, read_table_yanny, write_table_yanny
+
+
+register_identifier("yanny", Table, is_yanny)
+register_reader("yanny", Table, read_table_yanny)
+register_writer("yanny", Table, write_table_yanny)
+
+
+def group_contiguous(v):
+    groups = []
+    for k, g in groupby(enumerate(sorted(v)), lambda x: x[1] - x[0]):
+        group = list(map(lambda x: x[1], g))
+        groups.append((group[0], group[-1]))
+    return groups
+
+
+def get_observatories(apo: bool, lco: bool) -> Tuple[str, ...]:
+    """Get observatory names based on boolean flags.
+
+    Args:
+        apo: Whether to include APO observatory
+        lco: Whether to include LCO observatory
+
+    Returns:
+        Tuple of observatory names ("apo", "lco", or both)
+    """
+    if apo and not lco:
+        return ("apo",)
+    elif lco and not apo:
+        return ("lco",)
+    else:
+        return ("apo", "lco")
+
+
+def timestamp_to_mjd(v: float) -> float:
+    """Convert Unix timestamp to Modified Julian Date (MJD).
+
+    Args:
+        v: Unix timestamp in seconds
+
+    Returns:
+        Modified Julian Date as float
+    """
+    return (v / 86400.0) + 40587.5
+
+
+def get_current_mjd() -> int:
+    """Get current Modified Julian Date as integer.
+
+    Returns:
+        Current MJD as integer
+    """
+    return int(timestamp_to_mjd(time()))
+
+
+def datetime_to_mjd(date: str) -> int:
+    """Convert date string to Modified Julian Date.
+
+    Args:
+        date: Date string in format "YYYY-MM-DD"
+
+    Returns:
+        Modified Julian Date as integer
+    """
+    return int(timestamp_to_mjd(datetime.strptime(date, "%Y-%m-%d").timestamp()))
+
+def mjd_to_datetime(mjd: float) -> datetime:
+    """Convert Modified Julian Date to datetime object.
+
+    Args:
+        mjd: Modified Julian Date
+
+    Returns:
+        Datetime object
+    """
+    return Time(mjd, format='mjd').datetime
+
+def parse_mjds(mjd: Optional[int], mjd_start: Optional[int], mjd_end: Optional[int],
+               date: Optional[str], date_start: Optional[str], date_end: Optional[str],
+               earliest_mjd: int = 0) -> Tuple[Union[int, range, Tuple[int, ...]], int, int]:
+    """Parse MJD and date parameters to determine observation date range.
+
+    Args:
+        mjd: Single MJD value (can be negative for relative to current)
+        mjd_start: Start MJD for range (can be negative for relative to current)
+        mjd_end: End MJD for range (can be negative for relative to current)
+        date: Single date string in "YYYY-MM-DD" format
+        date_start: Start date string in "YYYY-MM-DD" format
+        date_end: End date string in "YYYY-MM-DD" format
+        earliest_mjd: Earliest allowed MJD value (default: 0)
+
+    Returns:
+        Tuple containing:
+            - MJD values (single int, range, or tuple)
+            - Start MJD (int)
+            - End MJD (int)
+
+    Raises:
+        ValueError: If more than one time specification method is provided
+        RuntimeError: If no valid time specification is found
+    """
+    has_mjd_range = mjd_start is not None or mjd_end is not None
+    has_date_range = date_start is not None or date_end is not None
+
+    current_mjd = get_current_mjd()
+    n_given = sum([has_mjd_range, has_date_range, mjd is not None, date is not None])
+    if n_given > 1:
+        raise ValueError(
+            "Cannot specify more than one of --mjd, --mjd-start/--mjd-end, --date, --date-start/--date-end"
+        )
+    if n_given == 0:
+        return ((current_mjd, ), current_mjd, current_mjd)
+    if mjd is not None:
+        if mjd < 0:
+            mjd += current_mjd
+        return ((mjd, ), mjd, mjd)
+    if has_mjd_range:
+        mjd_start = mjd_start or earliest_mjd
+        if mjd_start < 0:
+            mjd_start += current_mjd
+        mjd_end = mjd_end or current_mjd
+        if mjd_end < 0:
+            mjd_end += current_mjd
+        return (range(mjd_start, 1 + mjd_end), mjd_start, mjd_end)
+    if date is not None:
+        mjd = datetime_to_mjd(date)
+        return ((mjd, ), mjd, mjd)
+    if has_date_range:
+        mjd_start = earliest_mjd if date_start is None else datetime_to_mjd(date_start)
+        mjd_end = current_mjd if date_end is None else datetime_to_mjd(date_end)
+        return (range(mjd_start, 1 + mjd_end), mjd_start, mjd_end)
+
+    raise RuntimeError("Should not be able to get here")