lvm-tools 0.0.2__tar.gz

lvm_tools-0.0.2/.gitignore

@@ -0,0 +1,169 @@
+# vscode
+.vscode/
+
+# MacOS
+*.DS_Store
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+src/lvm_tools/_version.py
+# MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

lvm_tools-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Thomas Hilder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lvm_tools-0.0.2/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: lvm_tools
+Version: 0.0.2
+Summary: Lazily read/encapsulate LVM DRP data in a modular way
+Author-email: Tom Hilder <Thomas.Hilder@monash.edu>
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: astropy>=7.1.0
+Requires-Dist: dask>=2025.7.0
+Requires-Dist: numpy>=2.3.2
+Requires-Dist: scipy>=1.16.1
+Requires-Dist: xarray>=2025.7.1
+Description-Content-Type: text/markdown
+
+# lvm_tools
+
+Lightweight wrapper of [LVM DRP](https://github.com/sdss/lvmdrp) data with an emphasis on modularity. Allows for lazy reading via [`dask`](https://www.dask.org), especially useful for fitting large models. Designed for use with spectrospatial models via [`spectracles`](https://github.com/TomHilder/spectracles) but probably useful for other things too.
+
+Feel free to contact me personally if you have any questions at all.
+
+## Installation
+
+TODO
+
+## Usage
+
+TODO
+
+## Citation
+
+TODO
+
+## Help
+
+TODO
+
+## TODO
+
+- [ ] repr for FitData
+- [ ] Logging/hashing
+- [ ] Cache
+- [ ] OptConfig

lvm_tools-0.0.2/README.md

@@ -0,0 +1,28 @@
+# lvm_tools
+
+Lightweight wrapper of [LVM DRP](https://github.com/sdss/lvmdrp) data with an emphasis on modularity. Allows for lazy reading via [`dask`](https://www.dask.org), especially useful for fitting large models. Designed for use with spectrospatial models via [`spectracles`](https://github.com/TomHilder/spectracles) but probably useful for other things too.
+
+Feel free to contact me personally if you have any questions at all.
+
+## Installation
+
+TODO
+
+## Usage
+
+TODO
+
+## Citation
+
+TODO
+
+## Help
+
+TODO
+
+## TODO
+
+- [ ] repr for FitData
+- [ ] Logging/hashing
+- [ ] Cache
+- [ ] OptConfig

lvm_tools-0.0.2/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "lvm_tools"
+dynamic = ["version"]
+description = "Lazily read/encapsulate LVM DRP data in a modular way"
+readme = "README.md"
+authors = [{ name = "Tom Hilder", email = "Thomas.Hilder@monash.edu" }]
+requires-python = ">=3.13"
+dependencies = [
+    "astropy>=7.1.0",
+    "dask>=2025.7.0",
+    "numpy>=2.3.2",
+    "scipy>=1.16.1",
+    "xarray>=2025.7.1",
+]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+include = ["src/lvm_tools/py.typed"]
+exclude = ["**/__pycache__/**"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/**", "README.md", "LICENSE"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lvm_tools"]
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/lvm_tools/_version.py"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.version.raw-options]
+local_scheme = "no-local-version"
+
+[tool.ruff]
+line-length = 99 # Sorry PEP8 I'm a rebel

lvm_tools-0.0.2/src/lvm_tools/__init__.py

@@ -0,0 +1,10 @@
+from lvm_tools.config.data_config import DataConfig
+from lvm_tools.data.tile import LVMTile, LVMTileCollection
+from lvm_tools.fit_data.builder import FitDataBuilder
+
+__all__ = [
+    "LVMTile",
+    "LVMTileCollection",
+    "DataConfig",
+    "FitDataBuilder",
+]

lvm_tools-0.0.2/src/lvm_tools/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.0.2'
+__version_tuple__ = version_tuple = (0, 0, 2)

lvm_tools-0.0.2/src/lvm_tools/config/__init__.py

@@ -0,0 +1 @@
+"""config - subpackage for configurations used in data processing before fitting."""

lvm_tools-0.0.2/src/lvm_tools/config/data_config.py

@@ -0,0 +1,206 @@
+"""data_config.py - Objects for specifying configuration of data processing before fitting."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+
+import numpy as np
+
+from lvm_tools.config.validation import (
+    validate_apply_mask,
+    validate_excl_strategy,
+    validate_fib_status_incl,
+    validate_norm_strategy,
+    validate_offset,
+    validate_range,
+    validate_scale,
+)
+from lvm_tools.data.tile import LVMTileLike
+from lvm_tools.fit_data.filtering import (
+    BAD_FLUX_THRESHOLD,
+    ExcludeStrategy,
+    FibreStatus,
+)
+from lvm_tools.fit_data.normalisation import NormaliseStrategy
+from lvm_tools.fit_data.processing import get_normalisations, get_αδ_ranges, process_tile_data
+
+
+@dataclass(frozen=True)
+class DataConfig:
+    """
+    Configuration object for data processing before fitting.
+
+    args:
+        λ_range: tuple[float, float] - Wavelength range to include.
+        α_range: tuple[float, float] - Right Ascension range to include.
+        δ_range: tuple[float, float] - Declination range to include.
+        nans_strategy: ExcludeStrategy - Strategy for handling NaN values.
+        F_bad_strategy: ExcludeStrategy - Strategy for handling bad flux values. For "pixel", the flux range is applied to each pixel. For "spaxel", the flux range is applied to the median of all pixels in a spaxel.
+        F_range: tuple[float, float] - Flux range to include.
+        fibre_status_include: tuple[FibreStatus] - Fibre status values to include.
+        apply_mask: bool - Whether to apply a mask to the data.
+        normalise_F_strategy: NormaliseStrategy - Strategy for normalising flux data.
+        normalise_F_offset: float - Offset for normalising flux data.
+        normalise_F_scale: float - Scale for normalising flux data.
+        normalise_αδ_strategy: NormaliseStrategy - Strategy for normalising α and δ data.
+        normalise_αδ_offset: float - Offset for normalising α and δ data.
+        normalise_αδ_scale: float - Scale for normalising α and δ data.
+    """
+
+    # Data clipping ranges (aka choose data of interest)
+    λ_range: tuple[float, float] = (-np.inf, np.inf)
+    α_range: tuple[float, float] = (-np.inf, np.inf)
+    δ_range: tuple[float, float] = (-np.inf, np.inf)
+    # Bad data ranges and strategies (aka exclude bad data)
+    nans_strategy: ExcludeStrategy = "pixel"
+    F_bad_strategy: ExcludeStrategy = "spaxel"
+    F_range: tuple[float, float] = (BAD_FLUX_THRESHOLD, np.inf)
+    # Handling of flagged data
+    fibre_status_include: tuple[FibreStatus] = (0,)
+    apply_mask: bool = True
+    # Normalisation
+    normalise_F_strategy: NormaliseStrategy = "max only"
+    normalise_F_offset: float = 0.0
+    normalise_F_scale: float = 1.0
+    normalise_αδ_strategy: NormaliseStrategy = "padded"
+    normalise_α_offset: float = 0.0
+    normalise_α_scale: float = 1.0
+    normalise_δ_offset: float = 0.0
+    normalise_δ_scale: float = 1.0
+
+    def __post_init__(self) -> None:
+        validate_range(self.λ_range)
+        validate_range(self.α_range)
+        validate_range(self.δ_range)
+        validate_excl_strategy(self.nans_strategy)
+        validate_excl_strategy(self.F_bad_strategy)
+        validate_range(self.F_range)
+        validate_fib_status_incl(self.fibre_status_include)
+        validate_apply_mask(self.apply_mask)
+        validate_norm_strategy(self.normalise_F_strategy)
+        validate_norm_strategy(self.normalise_αδ_strategy)
+        validate_offset(self.normalise_F_offset)
+        validate_scale(self.normalise_F_scale)
+        validate_norm_strategy(self.normalise_αδ_strategy)
+        validate_offset(self.normalise_α_offset)
+        validate_scale(self.normalise_α_scale)
+        validate_offset(self.normalise_δ_offset)
+        validate_scale(self.normalise_δ_scale)
+
+    @staticmethod
+    def default() -> DataConfig:
+        return DataConfig()
+
+    @staticmethod
+    def from_tiles(
+        tiles: LVMTileLike,
+        λ_range: tuple[float, float] = (-np.inf, np.inf),
+        **overrides,
+    ) -> DataConfig:
+        # λ_range cannot be set automatically
+        α_range, δ_range = get_αδ_ranges(tiles)
+
+        # Instantiate a data config with calc'd + default + overrides
+        config_dict = DataConfig(λ_range=λ_range, α_range=α_range, δ_range=δ_range).to_dict()
+        config = DataConfig.from_dict(config_dict | overrides)
+
+        # Clip and filter the data
+        ds = process_tile_data(tiles, config)
+
+        # Calculate the normalisation parameters
+        (
+            (normalise_F_offset, normalise_F_scale),
+            (normalise_α_offset, normalise_α_scale),
+            (normalise_δ_offset, normalise_δ_scale),
+        ) = get_normalisations(ds, config)
+
+        # We want a square domain in the α, δ plane
+        norm_αδ_scale = max(normalise_α_scale, normalise_δ_scale)
+
+        # Update the config with the calculated values
+        norm_overrides = {
+            "normalise_F_offset": normalise_F_offset,
+            "normalise_F_scale": normalise_F_scale,
+            "normalise_α_offset": normalise_α_offset,
+            "normalise_α_scale": norm_αδ_scale,
+            "normalise_δ_offset": normalise_δ_offset,
+            "normalise_δ_scale": norm_αδ_scale,
+        }
+
+        # Merge partial config + norm + user overrides, with user overrides taking precedence
+        return DataConfig.from_dict(config.to_dict() | norm_overrides | overrides)
+
+    @staticmethod
+    def from_dict(config: dict) -> DataConfig:
+        if len(config) != len(DataConfig.default().to_dict()):
+            raise ValueError("config has the wrong number of entries.")
+        return DataConfig(**config)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    def __repr__(self) -> str:
+        def format_tuple(t):
+            """Format tuple with floats to 2 decimal places or scientific notation if very small."""
+            formatted = []
+            for x in t:
+                if isinstance(x, float):
+                    if abs(x) < 1e-3 and x != 0:
+                        formatted.append(f"{x:.2e}")
+                    else:
+                        formatted.append(f"{x:.2f}")
+                else:
+                    formatted.append(str(x))
+            return f"({', '.join(formatted)})"
+
+        def format_float(f):
+            """Format float to 2 decimal places, or scientific notation if very small."""
+            if abs(f) < 1e-3 and f != 0:
+                return f"{f:.2e}"
+            else:
+                return f"{f:.2f}"
+
+        lines = [f"{self.__class__.__name__}("]
+
+        lines = [f"{self.__class__.__name__} ({hex(id(self))}):"]
+
+        pad = 26
+
+        # Data clipping ranges
+        lines.append("    Data clipping ranges:")
+        lines.append(f"        {'λ_range:':{pad}}{format_tuple(self.λ_range)}")
+        lines.append(f"        {'α_range:':{pad}}{format_tuple(self.α_range)}")
+        lines.append(f"        {'δ_range:':{pad}}{format_tuple(self.δ_range)}")
+
+        # Bad data handling
+        lines.append("    Bad data handling:")
+        lines.append(f"        {'nans_strategy:':{pad}}'{self.nans_strategy}'")
+        lines.append(f"        {'F_bad_strategy:':{pad}}'{self.F_bad_strategy}'")
+        lines.append(f"        {'F_range:':{pad}}{format_tuple(self.F_range)}")
+
+        # Flagged data handling
+        lines.append("    Flagged data handling:")
+        lines.append(f"        {'fibre_status_include:':{pad}}{self.fibre_status_include}")
+        lines.append(f"        {'apply_mask:':{pad}}{self.apply_mask}")
+
+        # Flux normalisation
+        lines.append("    Flux normalisation:")
+        lines.append(f"        {'normalise_F_strategy:':{pad}}'{self.normalise_F_strategy}'")
+        lines.append(
+            f"        {'normalise_F_offset:':{pad}}{format_float(self.normalise_F_offset)}"
+        )
+        lines.append(f"        {'normalise_F_scale:':{pad}}{format_float(self.normalise_F_scale)}")
+
+        # Coordinate normalisation
+        lines.append("    Coordinate normalisation:")
+        lines.append(f"        {'normalise_αδ_strategy:':{pad}}'{self.normalise_αδ_strategy}'")
+        lines.append(
+            f"        {'normalise_α_offset:':{pad}}{format_float(self.normalise_α_offset)}"
+        )
+        lines.append(f"        {'normalise_α_scale:':{pad}}{format_float(self.normalise_α_scale)}")
+        lines.append(
+            f"        {'normalise_δ_offset:':{pad}}{format_float(self.normalise_δ_offset)}"
+        )
+        lines.append(f"        {'normalise_δ_scale:':{pad}}{format_float(self.normalise_δ_scale)}")
+
+        return "\n".join(lines)

lvm_tools-0.0.2/src/lvm_tools/config/validation.py

@@ -0,0 +1,58 @@
+"""validation.py - Validation functions for data processing configuration."""
+
+from typing import get_args
+
+import numpy as np
+
+from lvm_tools.fit_data.filtering import ExcludeStrategy, FibreStatus
+from lvm_tools.fit_data.normalisation import NormaliseStrategy
+
+
+def validate_range(x_range: tuple[float, float]) -> None:
+    # if not isinstance(x_range, tuple):
+    # raise TypeError("Data range must be in a tuple.")
+    if len(x_range) != 2:
+        raise ValueError(
+            "Data range must be a tuple with exactly two values (min, max)."
+        )
+    if x_range[1] < x_range[0]:
+        raise ValueError("Requested data range restriction has max < min.")
+
+
+def validate_excl_strategy(strategy: ExcludeStrategy) -> None:
+    if strategy not in get_args(ExcludeStrategy):
+        raise ValueError(f"Unknown exclusion strategy: {strategy}")
+
+
+def validate_norm_strategy(strategy: NormaliseStrategy) -> None:
+    if strategy not in get_args(NormaliseStrategy):
+        raise ValueError(f"Unknown normalisation strategy: {strategy}")
+
+
+def validate_fib_status_incl(fibre_status_include: tuple[FibreStatus]) -> None:
+    # if not isinstance(fibre_status_include, tuple):
+    # raise TypeError("fibre_status_include must be a tuple.")
+    for fs in fibre_status_include:
+        if fs not in get_args(FibreStatus):
+            raise ValueError(f"Unknown fibre status: {fs}")
+
+
+def validate_offset(offset: float) -> None:
+    if not isinstance(offset, (float, np.floating)):
+        raise TypeError("offset must be float.")
+    if not np.isfinite(offset):
+        raise Exception("Bad offset (nan or infty).")
+
+
+def validate_scale(scale: float) -> None:
+    if not isinstance(scale, (float, np.floating)):
+        raise TypeError("scale must be float.")
+    if not np.isfinite(scale):
+        raise Exception("Bad scale (nan or infty).")
+    if scale <= 0:
+        raise Exception("Scale is not positive, but it must be.")
+
+
+def validate_apply_mask(apply_mask: bool) -> None:
+    if not isinstance(apply_mask, bool):
+        raise TypeError("apply_mask must be a boolean.")

lvm_tools-0.0.2/src/lvm_tools/data/__init__.py

@@ -0,0 +1 @@
+"""data - subpackage for reading and encapsulating LVM data."""

lvm_tools-0.0.2/src/lvm_tools/data/coordinates.py

@@ -0,0 +1,73 @@
+"""coordinates.py - observation time and location extraction for LVM data processing."""
+
+# NOTE: Code is generated by an LLM and may not be fully robust.
+
+import astropy.units as u
+from astropy.coordinates import EarthLocation
+from astropy.io.fits import Header
+from astropy.time import Time
+
+
+def get_mjd(header: Header) -> float:
+    # Method 1: Use INTSTART and INTEND if available (most precise)
+    if "INTSTART" in header and "INTEND" in header:
+        start_time = Time(header["INTSTART"], format="isot")
+        end_time = Time(header["INTEND"], format="isot")
+        mid_time = start_time + (end_time - start_time) / 2
+        # print(header["MJD"])
+        # mid_time = Time(header["MJD"], format="mjd")
+        # print(mid_time.mjd)
+        # print()
+
+        # Validation: check against header EXPTIME
+        # calculated_exptime = (end_time - start_time).to(u.second).value
+        # header_exptime = header.get("EXPTIME", 0.0)
+        # if abs(calculated_exptime - header_exptime) > 1.0:  # Allow 1s tolerance
+        #     print(
+        #         f"  WARNING: Calculated exptime ({calculated_exptime:.1f}s) differs from header EXPTIME ({header_exptime}s)"
+        #     )
+
+        return mid_time.mjd
+
+    # # Method 2: Use OBSTIME + EXPTIME/2 as fallback
+    # elif "OBSTIME" in header and "EXPTIME" in header:
+    #     start_time = Time(header["OBSTIME"], format="isot")
+    #     exptime = header["EXPTIME"] * u.second
+    #     mid_time = start_time + exptime / 2
+
+    #     return mid_time.mjd
+
+    # # Method 3: Use header MJD + EXPTIME/2 (least precise, integer MJD)
+    # elif "MJD" in header and "EXPTIME" in header:
+    #     mjd_start = header["MJD"]  # This appears to be integer MJD
+    #     exptime_days = header["EXPTIME"] / 86400.0  # Convert seconds to days
+    #     mjd_mid = mjd_start + exptime_days / 2
+
+    #     return mjd_mid
+
+    else:
+        raise ValueError("Could not find sufficient time information in header")
+
+
+def get_observatory_code(header: Header) -> str:
+    observatory = header.get("OBSERVAT", "").strip()
+
+    # Just return the observatory code string
+    # You can convert to EarthLocation later when needed
+    known_observatories = ["LCO"]  # Add other LVM observatory codes as needed
+
+    if observatory in known_observatories:
+        return observatory
+    else:
+        raise ValueError(
+            f"Unknown observatory: {observatory}. Known observatories: {known_observatories}"
+        )
+
+
+def get_observatory_location(observatory: str) -> EarthLocation:
+    # LCO = Las Campanas Observatory
+    if observatory == "LCO":
+        return EarthLocation.of_site("Las Campanas Observatory")
+    else:
+        # Add other observatories as needed
+        raise ValueError(f"Unknown observatory: {observatory}")