sdss-almanac 0.2.1__py3-none-any.whl

almanac/data_models/exposure.py

@@ -0,0 +1,350 @@
+import os
+import numpy as np
+from astropy.table import Table
+from functools import partial, cached_property
+from pydantic import BaseModel, Field, computed_field, field_validator, model_validator
+from typing import Optional, Tuple, Union
+
+from almanac import logger, config, utils
+
+from almanac.data_models.fps import FPSTarget
+from almanac.data_models.plate import PlateTarget
+from almanac.data_models.types import *
+from almanac.data_models.utils import (
+    get_headers, match_planned_to_plugged, get_exposure_path,
+    get_exposure_string, mjd_to_exposure_prefix
+)
+
+from almanac.qa import lookup_bad_exposures
+
+
+class Exposure(BaseModel):
+
+    #> Basic Information
+    observatory: Observatory = Field(description="Observatory name")
+    mjd: int = Field(description="MJD of the exposure")
+    exposure: int = Field(description="Exposure number", ge=1)
+    prefix: Optional[Prefix] = Field(description="Raw exposure basename prefix", default=None)
+
+    #> Exposure Information
+    name: Optional[str] = Field(
+        default="",
+        description=(
+            "The `name` field in the exposure header often refers to the plugged"
+            "plate name, which describes which targets were observed."
+        )
+    )
+    n_read: int = Field(default=0, alias="nread", ge=0)
+    image_type: ImageType = Field(alias="imagetyp")
+    observer_comment: Optional[str] = Field(default="", alias="obscmnt")
+
+    #> Identifiers
+    map_id: int = Field(default=-1, alias="mapid")
+    cart_id: int = Field(default=-1, alias="cartid")
+    plate_id: int = Field(default=-1, alias="plateid")
+    field_id: int = Field(default=-1, alias="fieldid")
+    design_id: int = Field(default=-1, alias="designid")
+    config_id: int = Field(default=-1, alias="configid")
+
+    #> Observing Conditions
+    seeing: float = Field(default=float('NaN'))
+
+    #> Instrument State
+    focus: float = Field(default=float('NaN'))
+    collpist: float = Field(default=float('NaN'))
+    colpitch: float = Field(default=float('NaN'))
+    dithered_pixels: float = Field(default=float('NaN'), alias="dithpix")
+    lamp_quartz: int = Field(default=-1, alias="lampqrtz", ge=-1, le=1)
+    lamp_thar: int = Field(default=-1, alias="lampthar", ge=-1, le=1)
+    lamp_une: int = Field(default=-1, alias="lampune", ge=-1, le=1)
+
+    _targets: Optional[Tuple[Union[FPSTarget, PlateTarget]]] = None
+
+    @computed_field(description="Exposure string used in path")
+    def exposure_string(self) -> str:
+        return get_exposure_string(self.mjd, self.exposure)
+
+    @computed_field(description="Whether this exposure is from the FPS era")
+    def fps(self) -> bool:
+        start = dict(apo=59423, lco=59810)[self.observatory]
+        return self.mjd >= start
+
+    #@computed_field(description="FPI")
+    #def fpi(self) -> bool:
+    #    return "fpi" in self.observer_comment.lower()
+
+    #@computed_field(description="Sparse pak mode")
+    #def sparse_pak(self) -> bool:
+    #    return "sparse" in self.observer_comment.lower()
+
+    @computed_field
+    def flagged_bad(self) -> bool:
+        return (self.observatory, self.mjd, self.exposure) in lookup_bad_exposures
+
+    @computed_field
+    def chip_flags(self) -> int:
+        return int(np.sum(2**np.where(list(map(os.path.exists, self.paths)))[0]))
+
+    # Validations
+    @field_validator('prefix', mode="before")
+    def validate_prefix(cls, v, values):
+        if v is None:
+            return dict(apo="apR", lco="asR").get(values.get("observatory"))
+        return v
+
+    @field_validator("observer_comment", mode="before")
+    def sanitise_observer_comment(cls, v) -> str:
+        if v is None or str(v).lower() == "none":
+            return ""
+        return v.strip()
+
+    @field_validator('image_type', mode="before")
+    def validate_descriptive_type(cls, v):
+        return v.lower()
+
+    @field_validator('cart_id', mode="before")
+    def validate_cart_id(cls, v):
+        if isinstance(v, str) and v.strip().upper() == 'FPS':
+            return 0
+        return empty_string_to_int(v, -1)
+
+    @field_validator('map_id', 'plate_id', 'field_id', 'design_id', 'config_id', mode="before")
+    def validate_identifiers(cls, v):
+        return empty_string_to_int(v, -1)
+
+    @field_validator('seeing', 'focus', 'collpist', 'colpitch', 'dithered_pixels', mode="before")
+    def validate_floats(cls, v):
+        try:
+            return float(v)
+        except:
+            return float('NaN')
+
+    @field_validator('lamp_quartz', 'lamp_thar', 'lamp_une', mode="before")
+    def validate_lamps(cls, v):
+        return {'F': 0, 'T': 1}.get(str(v).strip().upper(), -1)
+
+    @model_validator(mode="after")
+    def check_fields(self):
+        if self.observer_comment is not None and self.image_type != "twilightflat":
+            sanitised = self.observer_comment.lower().replace(' ', '')
+            if 'skyflat' in sanitised or 'twilight' in sanitised:
+                self.image_type = 'twilightflat'
+        return self
+
+    # TODO: we may want to change this to be way more descriptive, particularly
+    #       when we start doing QA to make sure exposures look like they should
+    @property
+    def qa_metadata(self) -> Optional[dict]:
+        print("Warning: The `qa_metadata` property will change in the future")
+        return lookup_bad_exposures.get((self.observatory, self.mjd, self.exposure), None)
+
+    @property
+    def plugged_mjd(self) -> int:
+        try:
+            return int(self.name.split("-")[1])
+        except:
+            return -1
+
+    @property
+    def plugged_iteration(self) -> str:
+        try:
+            return self.name.split("-")[2]
+        except:
+            return ""
+
+    @property
+    def paths(self) -> Tuple[str]:
+        return tuple(
+            map(
+                partial(
+                    get_exposure_path,
+                    self.observatory,
+                    self.mjd,
+                    self.prefix,
+                    self.exposure
+                ),
+                "abc"
+            )
+        )
+
+    @property
+    def plate_hole_path(self):
+        return (
+            f"{config.platelist_dir}/"
+            f"{str(self.plate_id)[:-2].zfill(4)}XX/"
+            f"{self.plate_id:0>6.0f}/"
+            f"plateHoles-{self.plate_id:0>6.0f}.par"
+        )
+
+    @property
+    def plug_map_path(self):
+        return (
+            f"{config.mapper_dir}/"
+            f"{self.observatory}/"
+            f"{self.plugged_mjd}/"
+            f"plPlugMapM-{self.plate_id}-{self.plugged_mjd}-{self.plugged_iteration}.par"
+        )
+
+    @property
+    def config_summary_path(self):
+        directory = (
+            f"{config.sdsscore_dir}/"
+            f"{self.observatory}/"
+            f"summary_files/"
+            f"{str(self.config_id)[:-3].zfill(3)}XXX/"
+            f"{str(self.config_id)[:-2].zfill(4)}XX/"
+        )
+        # fall back to confSummary if confSummaryFS does not exist
+        for flavor in ("FS", ""):
+            path = f"{directory}/confSummary{flavor}-{self.config_id}.par"
+            if os.path.exists(path):
+                return path
+
+        raise FileNotFoundError(f"Could not find confSummary file for config {self.config_id} in {directory}")
+
+    @classmethod
+    def from_keys(
+        cls,
+        mjd: int,
+        observatory: str,
+        exposure: int,
+        prefix: Optional[Prefix] = None,
+        chip: Optional[Chip] = None
+    ) -> "Exposure":
+        """
+        Create an Exposure instance from basic identifying keys.
+
+        :param mjd:
+            MJD of the exposure.
+
+        :param observatory:
+            Observatory name (e.g., 'apo', 'lco').
+
+        :param exposure:
+            Exposure number.
+
+        :param prefix: [optional]
+            Prefix for the exposure file (e.g., 'apR', 'asR'). If not provided,
+            defaults to 'apR' for APO and 'asR' for LCO.
+
+        :param chip: [optional]
+            Chip identifier ('a', 'b', or 'c'). If not provided, will check
+            all chips in order.
+
+        :returns:
+            An instance of the Exposure class populated with data extracted from
+            the file headers.
+        """
+
+        if prefix is None:
+            prefix = dict(apo="apR", lco="asR").get(observatory, "apR")
+
+        for chip in (chip or "abc"):
+            path = get_exposure_path(observatory, mjd, prefix, exposure, chip)
+            if os.path.exists(path):
+                headers = get_headers(path)
+                return cls(
+                    observatory=observatory,
+                    mjd=mjd,
+                    exposure=exposure,
+                    prefix=prefix,
+                    **headers
+                )
+        raise FileNotFoundError(f"No exposure files found for {observatory} {mjd} {exposure} {prefix}")
+
+    @classmethod
+    def from_path(cls, path: str) -> "Exposure":
+        """
+        Create an Exposure instance from a given file path.
+
+        :param path:
+            Full path to the exposure file.
+
+        :returns:
+            An instance of the Exposure class populated with data extracted from
+            the file path and headers.
+        """
+        *_, observatory, mjd, basename = path.split("/")
+        prefix, chip, cumulative_exposure = basename.split("-")
+        exposure = int(cumulative_exposure.split(".")[0]) - mjd_to_exposure_prefix(mjd)
+        headers = get_headers(path)
+        return cls(
+            observatory=observatory,
+            mjd=mjd,
+            exposure=exposure,
+            prefix=prefix,
+            **headers
+        )
+
+    @cached_property
+    def headers(self) -> dict:
+        for path in self.paths:
+            if os.path.exists(path):
+                return get_headers(path)
+        raise FileNotFoundError(f"No exposure files found for {self.observatory} {self.mjd} {self.exposure} {self.prefix}")
+
+    @cached_property
+    def fiber_map(self):
+        return Table.read(self.config_summary_path, format="yanny", tablename="FIBERMAP")
+
+    @cached_property
+    def plug_map(self):
+        return Table.read(self.plug_map_path, format="yanny", tablename="PLUGMAPOBJ")
+
+    @cached_property
+    def plate_hole_map(self):
+        return Table.read(self.plate_hole_path, format="yanny", tablename="STRUCT1")
+
+
+    @cached_property
+    def targets(self) -> Tuple[Union[FPSTarget, PlateTarget]]:
+        if self._targets is None:
+
+            if (
+                (self.image_type == "object")
+            &   (
+                    (self.fps and self.config_id > 0)
+                |   (not self.fps and self.plate_id > 0)
+            )
+            ):
+                if self.fps:
+                    factory = FPSTarget
+                    targets = self.fiber_map
+                    keep = (targets["fiberType"] == "APOGEE") & (targets["fiberId"] > 0)
+                    targets = targets[keep]
+                else:
+                    factory = PlateTarget
+                    bad_exposure_notes = (
+                        lookup_bad_exposures
+                        .get((self.observatory, self.mjd, self.exposure), {})
+                        .get("notes", None)
+                    )
+                    if bad_exposure_notes == "missing_plug_map_file":
+                        targets = []
+                    else:
+                        targets = match_planned_to_plugged(self.plate_hole_map, self.plug_map)
+                        if targets:
+                            # Plugged MJD is necessary to understand where the fiber mapping
+                            # went wrong in early plate era.
+                            targets["plugged_mjd"] = self.plugged_mjd
+                            targets["observatory"] = self.observatory
+
+                self._targets = tuple([factory(**r) for r in targets])
+            else:
+                self._targets = tuple()
+        return self._targets
+
+    def __repr__(self):
+        return f"{self.__repr_name__()}(observatory={self.observatory}, mjd={self.mjd}, exposure={self.exposure}, image_type={self.image_type})"
+
+    class Config:
+        validate_by_name = True
+        validate_assignment = True
+
+
+def empty_string_to_int(v, default) -> int:
+    if isinstance(v, str) and v.strip() == '':
+        return default
+    elif v is None:
+        return default
+    return int(v)

almanac/data_models/fps.py

@@ -0,0 +1,109 @@
+import numpy as np
+from typing import Literal
+from typing_extensions import Annotated
+from pydantic import BaseModel, Field, model_validator, field_validator
+
+from almanac.data_models.types import *
+from almanac.data_models.utils import sanitise_twomass_designation
+
+class FPSTarget(BaseModel):
+
+    """A target that was observed with the SDSS-V Fiber Positioning System."""
+
+    # Target information
+    sdss_id: Int64 = Field(default=-1)
+    catalogid: Int64 = Field(default=-1)
+    twomass_designation: str = Field(default="", alias="tmass_id")
+    category: Literal[Category] = Field(description="Category of the target")
+    cadence: str = Field(description="Cadence identifier", default="")
+    firstcarton: str = Field(description="Main carton from which this carton was drawn", default="")
+    program: str = Field(description="Program for 'firstcarton'", default="")
+
+    # Positioner and hole identifiers
+    positioner_id: int = Field(alias='positionerId', description="Positioner identifier", default=-1)
+    hole_id: str = Field(alias='holeId', description="Hole ID in which the positioner is sitting", default="")
+    hole_type: HoleType = Field(alias="holeType", description="Type of hole", default="fps")
+    planned_hole_type: HoleType = Field(alias="holetype", description="Hole type string", default="fps")
+
+    fiber_type: str = Field(alias='fiberType', description="Type of fiber", default="")
+    assigned: bool = Field(
+        default=False,
+        description=(
+            "Target is assigned to this fiber in `robostrategy`. If False, no "
+            "target assigned for this fiber (likely BOSS instead), and no "
+            "targeting information available"
+        )
+    )
+
+    # Status flags
+    on_target: bool = Field(description="Fiber placed on target", default=False)
+    disabled: bool = Field(description="Fiber is disabled", default=False)
+    valid: bool = Field(description="Converted on-sky coordinates to robot (α,β)", default=False)
+    decollided: bool = Field(description="Positioner had to be moved to decollide it", default=False)
+
+    # Position coordinates
+    x_wok: float = Field(description="x-coordinate in the wok frame", default=float('NaN'), alias="xwok")
+    y_wok: float = Field(description="y-coordinate in the wok frame", default=float('NaN'), alias="ywok")
+    z_wok: float = Field(description="z-coordinate in the wok frame", default=float('NaN'), alias="zwok")
+    x_focal: float = Field(description="x-coordinate in the focal plane", default=float('NaN'), alias='xFocal')
+    y_focal: float = Field(description="y-coordinate in the focal plane", default=float('NaN'), alias='yFocal')
+
+    # Angles
+    alpha: float = Field(description="Alpha angle of the positioner arm", default=float('NaN'))
+    beta: float = Field(description="Beta angle of the positioner arm", default=float('NaN'))
+
+    # Target coordinates
+    ra: float = Field(alias="racat", description="Right Ascension [deg]")
+    dec: float = Field(alias="deccat", description="Declination [deg]")
+    alt: float = Field(description="Altitude of the fiber on the sky [deg]", default=float('NaN'), alias="alt_observed")
+    az: float = Field(description="Azimuth of the fiber on the sky [deg]", default=float('NaN'), alias="az_observed")
+
+    # Wavelength information
+    lambda_design: float = Field(default=0.0)
+    lambda_eff: float = Field(default=0.0)
+    coord_epoch: float = Field(default=0.0)
+
+    # Instrument identifiers
+    spectrograph_id: int = Field(description="Spectrograph identifier", alias='spectrographId', default=-1)
+    fiber_id: int = Field(description="Fiber identifier", alias='fiberId', default=-1)
+
+    # Position deltas
+    delta_ra: float = Field(description="The amount in RA this fiber has been offset", default=float('NaN'))
+    delta_dec: float = Field(description="The amount in Dec this fiber has been offset", default=float('NaN'))
+
+    # Target of opportunity
+    too: bool = Field(default=False, description="Target of opportunity")
+    too_id: int = Field(default=-1)
+    too_program: str = Field(default="")
+
+    @property
+    def expected_to_be_assigned_sdss_id(self) -> bool:
+        """ A helper function so we don't try to cross-match sky targets for SDSS IDs. """
+        return (self.catalogid > 0
+            and not self.category.startswith("sky_")
+            and self.category != ""
+        )
+
+    @field_validator("twomass_designation", mode="before")
+    def strip_twomass_designation(cls, v) -> str:
+        """ Convert a target ID to a standardized designation format. """
+        return sanitise_twomass_designation(v)
+
+
+    class Config:
+        validate_by_name = True
+        validate_assignment = True
+        arbitrary_types_allowed = True
+
+
+    @model_validator(mode="after")
+    def fix_early_fiber_duplicates(self):
+        # From https://github.com/sdss/apogee_drp/blob/4ab6a04e448b279f2514550802b6732693e9847a/python/apogee_drp/utils/plugmap.py#L170-L180
+        if self.spectrograph_id == 2:
+            if self.positioner_id == 650 and self.fiber_id == 175:
+                self.fiber_id = 275
+            if self.positioner_id == 880 and self.fiber_id == 176:
+                self.fiber_id = 276
+            if self.positioner_id == 177 and self.fiber_id == 186:
+                self.fiber_id = 286
+        return self

almanac/data_models/plate.py

@@ -0,0 +1,142 @@
+from typing import Literal
+from pydantic import BaseModel, Field, validator, model_validator, computed_field
+
+from almanac.data_models.types import *
+from almanac.data_models.utils import sanitise_twomass_designation
+
+class PlateTarget(BaseModel):
+
+    """ A target that was observed with plates. """
+
+    # Target information
+    sdss_id: Int64 = Field(default=-1)
+    catalogid: Int64 = Field(default=-1)
+
+    @computed_field
+    def twomass_designation(self) -> str:
+        """ Convert a target ID to a standardized designation format. """
+        return sanitise_twomass_designation(self.twomass_id or self.target_ids)
+
+    twomass_id: str = Field(alias="tmass_id", default="")
+    target_ids: str = Field(alias="targetids", default="")
+    category: Literal[Category] = Field(description="Category of the target", alias="targettype")
+
+    # Positioner and hole identifiers
+    observatory: Literal[Observatory] = Field(description="Observatory") # necessary for fiber mapping fixes
+    hole_type: HoleType = Field(alias="holeType", description="Type of hole")
+    planned_hole_type: HoleType = Field(alias="holetype", description="Hole type string")
+    obj_type: ObjType = Field(alias="objType", description="Object type", default="na")
+    assigned: bool = Field(description="Assigned flag", default=False)
+
+    # Status flags
+    conflicted: bool = Field(description="Conflicted flag", default=False)
+    ranout: bool = Field(description="Ran out flag", default=False)
+    outside: bool = Field(description="Outside flag", default=False)
+
+    # Position coordinates
+    x_focal: float = Field(description="X focal plane coordinate", alias="xfocal", default=float('NaN'))
+    y_focal: float = Field(description="Y focal plane coordinate", alias="yfocal", default=float('NaN'))
+    xf_default: float = Field(description="Default X focal coordinate", default=float('NaN'))
+    yf_default: float = Field(description="Default Y focal coordinate", default=float('NaN'))
+
+    # Target coordinates
+    ra: float = Field(description="Right ascension [deg]")
+    dec: float = Field(description="Declination [deg]")
+
+    # Wavelength information
+    lambda_eff: float = Field(description="Effective wavelength", default=0.0)
+    zoffset: float = Field(description="Z offset", default=0.0)
+
+    # Instrument identifiers
+    spectrograph_id: int = Field(alias="spectrographId", description="Spectrograph ID", default=-1)
+    fiber_id: int = Field(alias="fiberId", description="Fiber ID", default=-1)
+    planned_fiber_id: int = Field(alias="fiberid", description="Fiber ID", default=-1)
+    throughput: int = Field(description="Throughput value", default=-1)
+
+    # Plate-specific information
+    iplateinput: int = Field(description="Plate input ID", default=-1)
+    pointing: int = Field(description="Pointing number", default=-1)
+    offset: int = Field(description="Offset value", default=-1)
+    block: int = Field(description="Block number", default=-1)
+    iguide: int = Field(description="Guide flag", default=-1)
+    bluefiber: int = Field(description="Blue fiber flag", default=-1)
+    chunk: int = Field(description="Chunk number", default=-1)
+    ifinal: int = Field(description="Final flag", default=-1)
+    plugged_mjd: int = Field(description="MJD when this plate was plugged", default=-1) # necessary for fiber mapping fixes
+    fix_fiber_flag: int = Field(default=0, description="Whether this fiber mapping was fixed in software")
+
+    # Physical properties
+    diameter: float = Field(default=-1, description="Diameter")
+    buffer: float = Field(default=-1, description="Buffer size")
+    priority: int = Field(default=-1, description="Target priority")
+
+
+    @validator('hole_type', 'planned_hole_type', 'obj_type', pre=True)
+    def enforce_lower_case(cls, v):
+        return v.lower()
+
+    @validator('category', pre=True)
+    def validate_category(cls, v):
+        # Make consistent across FPS and plate era.
+        translate_from_plate_to_fps = {
+            "sky": "sky_apogee",
+            "standard": "standard_apogee",
+            "na": ""
+        }
+        return translate_from_plate_to_fps.get(v.lower(), v)
+
+    class Config:
+        validate_by_name = True
+        validate_assignment = True
+        arbitrary_types_allowed = True
+
+    @property
+    def expected_to_be_assigned_sdss_id(self) -> bool:
+        """ A helper function so we don't try to cross-match sky targets for SDSS IDs. """
+        return (
+            (self.catalogid > 0) | (self.twomass_designation != "")
+
+            and not self.category.startswith("sky_")
+            and self.category != ""
+        )
+
+
+    @model_validator(mode="after")
+    def fix_fiber_mappings(self):
+        # Dates from /uufs/chpc.utah.edu/common/home/sdss09/software/apogee/Linux/apogee/trunk/data/cal/apogee-n.par
+        # The Python mapping logic originates from:
+        #   https://github.com/sdss/apogee_drp/blob/4ab6a04e448b279f2514550802b6732693e9847a/python/apogee_drp/utils/plugmap.py#L210-L238
+        # but that code has a bug in it (see below)
+
+        # Check against fix_fiber_flag to avoid recursively fixing things.
+        if self.observatory == "apo" and self.fix_fiber_flag == 0:
+            if 56764 <= self.plugged_mjd <= 56773 and self.fiber_id >= 0:
+                self.fix_fiber_flag = 1
+                sub_id = (self.fiber_id - 1) % 30
+                bundle_id = (self.fiber_id - sub_id) // 30
+                self.fiber_id = (9 - bundle_id) * 30 + sub_id + 1
+            if 58034 <= self.plugged_mjd <= 58046 and self.hole_type == "object" and self.spectrograph_id == 2:
+                self.fix_fiber_flag = 2
+                # Note that the DRP code has this in a way where it ONLY changes
+                # fibers 31, 37, 45, and 54, but their expressions are written in
+                # a way that you would think they are meant to be ranges.
+
+                # This is because the DRP code has a transcription error from the
+                # original IDL code:
+                #   https://github.com/sdss/apogee/blob/master/pro/apogeereduce/aploadplugmap.pro#L210-L221
+
+                offset_ranges = [
+                    (31, 36, +23),
+                    (37, 44, +8),
+                    (45, 52, -8),
+                    (54, 59, -23),
+                ]
+                for lower, upper, offset in offset_ranges:
+                    if (lower <= self.fiber_id) & (self.fiber_id <= upper):
+                        self.fiber_id += offset
+                        break
+
+                if self.fiber_id in (53, 60):
+                    self.fiber_id = -1  # unpopulated fiber
+
+        return self

almanac/data_models/types.py

@@ -0,0 +1,87 @@
+import numpy as np
+from typing import Literal
+from typing_extensions import Annotated
+from pydantic import BeforeValidator
+
+def validate_np_int64(v):
+    if not isinstance(v, np.int64):
+        return np.int64(v)
+    return v
+
+Int64 = Annotated[np.int64, BeforeValidator(validate_np_int64)]
+
+
+Observatory = Literal["apo", "lco"]
+Prefix = Literal["apR", "asR"]
+Chip = Literal["a", "b", "c"]
+
+ImageType = Literal[
+    "blackbody",
+    "dark",
+    "object",
+    "domeflat",
+    "arclamp",
+    "twilightflat",
+    "internalflat",
+    "quartzflat",
+    "missing"
+]
+Category = Literal[
+    "",
+    "science",
+    "sky_apogee",
+    "sky_boss",
+    "standard_apogee",
+    "standard_boss",
+    "open_fiber"
+]
+
+HoleType = Literal[
+    "object",
+    "coherent_sky",
+    "guide",
+    "light_trap",
+    "alignment",
+    "quality",
+    "manga",
+    "manga_single",
+    "manga_alignment",
+    "acquisition_center",
+    "acquisition_offaxis",
+    "apogee",
+    "center",
+    "trap",
+    "boss",
+    "apogee_shared",
+    "apogee_south",
+    "bosshalf",
+    "boss_shared",
+    "fps"
+]
+
+ObjType = Literal[
+    "galaxy",
+    "qso",
+    "star_bhb",
+    "star_carbon",
+    "star_brown_dwarf",
+    "star_sub_dwarf",
+    "star_caty_var",
+    "star_red_dwarf",
+    "star_white_dwarf",
+    "redden_std",
+    "spectrophoto_std",
+    "hot_std",
+    "rosat_a",
+    "rosat_b",
+    "rosat_c",
+    "rosat_d",
+    "serendipity_blue",
+    "serendipity_first",
+    "serendipity_red",
+    "serendipity_distant",
+    "serendipity_manual",
+    "qa",
+    "sky",
+    "na",
+]