pyreduce-astro 0.7a7__cp314-cp314-win_amd64.whl → 0.7b1__cp314-cp314-win_amd64.whl

pyreduce/__main__.py

@@ -38,7 +38,7 @@ def cli():
 
 @cli.command()
 @click.argument("instrument")
-@click.argument("target")
+@click.option("--target", "-t", default=None, help="Target star name or regex pattern")
 @click.option("--night", "-n", default=None, help="Observation night (YYYY-MM-DD)")
 @click.option("--channel", "-c", default=None, help="Instrument channel")
 @click.option(
@@ -54,7 +54,7 @@ def cli():
     help="Base directory for data (default: $REDUCE_DATA or ~/REDUCE_DATA)",
 )
 @click.option(
-    "--input-dir", "-i", default="raw", help="Input directory relative to base"
+    "--input-dir", "-i", default=None, help="Input directory relative to base"
 )
 @click.option(
     "--output-dir", "-o", default="reduced", help="Output directory relative to base"
@@ -89,7 +89,6 @@ def run(
     """Run the reduction pipeline.
 
     INSTRUMENT: Name of the instrument (e.g., UVES, HARPS, XSHOOTER)
-    TARGET: Target star name or regex pattern
     """
     from .configuration import get_configuration_for_instrument, load_settings_override
     from .reduce import main as reduce_main
@@ -111,19 +110,22 @@ def run(
         config = load_settings_override(config, settings)
 
     # Run reduction
-    reduce_main(
-        instrument=instrument,
-        target=target,
-        night=night,
-        channels=channel,
-        steps=steps,
-        base_dir=base_dir or "",
-        input_dir=input_dir,
-        output_dir=output_dir,
-        configuration=config,
-        order_range=order_range,
-        plot=plot,
-    )
+    try:
+        reduce_main(
+            instrument=instrument,
+            target=target,
+            night=night,
+            channels=channel,
+            steps=steps,
+            base_dir=base_dir,
+            input_dir=input_dir,
+            output_dir=output_dir,
+            configuration=config,
+            order_range=order_range,
+            plot=plot,
+        )
+    except FileNotFoundError as e:
+        raise click.ClickException(str(e)) from None
 
 
 @cli.command()
@@ -345,31 +347,96 @@ def make_step_command(step_name):
             config = get_configuration_for_instrument(instrument)
             if settings:
                 config = load_settings_override(config, settings)
-            step_config = config.get(step_name, {})
-            step_config["plot"] = plot
 
-            # Get the step class
+            # Step classes that support --file (take raw files as input)
             step_classes = {
                 "bias": reduce_module.Bias,
                 "flat": reduce_module.Flat,
                 "trace": reduce_module.OrderTracing,
                 "curvature": reduce_module.SlitCurvatureDetermination,
                 "scatter": reduce_module.BackgroundScatter,
-                "norm_flat": reduce_module.NormalizeFlatField,
                 "wavecal_master": reduce_module.WavelengthCalibrationMaster,
-                "wavecal_init": reduce_module.WavelengthCalibrationInitialize,
-                "wavecal": reduce_module.WavelengthCalibrationFinalize,
                 "freq_comb_master": reduce_module.LaserFrequencyCombMaster,
-                "freq_comb": reduce_module.LaserFrequencyCombFinalize,
                 "science": reduce_module.ScienceExtraction,
-                "continuum": reduce_module.ContinuumNormalization,
             }
 
+            # Steps that don't take raw files - --file makes no sense
+            no_file_steps = {
+                "mask",
+                "norm_flat",
+                "wavecal_init",
+                "wavecal",
+                "freq_comb",
+                "continuum",
+                "finalize",
+                "rectify",
+            }
+
+            if step_name in no_file_steps:
+                raise click.ClickException(
+                    f"Step '{step_name}' does not accept raw files. "
+                    f"Run without --file to use the pipeline."
+                )
+
             if step_name not in step_classes:
                 raise click.ClickException(
                     f"Step '{step_name}' does not support --file option"
                 )
 
+            def make_step(name):
+                """Create a step instance."""
+                step_class = {
+                    "mask": reduce_module.Mask,
+                    "bias": reduce_module.Bias,
+                    "flat": reduce_module.Flat,
+                    "trace": reduce_module.OrderTracing,
+                    "curvature": reduce_module.SlitCurvatureDetermination,
+                    "scatter": reduce_module.BackgroundScatter,
+                    "norm_flat": reduce_module.NormalizeFlatField,
+                    "wavecal_master": reduce_module.WavelengthCalibrationMaster,
+                    "freq_comb_master": reduce_module.LaserFrequencyCombMaster,
+                    "science": reduce_module.ScienceExtraction,
+                }.get(name)
+                if not step_class:
+                    return None
+                step_config = config.get(name, {}).copy()
+                step_config["plot"] = 0  # No plots for dependency loading
+                return step_class(
+                    inst,
+                    channel,
+                    target=target or "",
+                    night=night,
+                    output_dir=output_dir_full,
+                    order_range=None,
+                    **step_config,
+                )
+
+            def load_dependency(name, loaded):
+                """Load a dependency from disk."""
+                if name in loaded:
+                    return loaded[name]
+                if name == "config":
+                    loaded["config"] = config
+                    return config
+                dep_step = make_step(name)
+                if dep_step is None:
+                    return None
+                # Load this step's dependencies first
+                for sub_dep in dep_step.loadDependsOn:
+                    load_dependency(sub_dep, loaded)
+                # Build kwargs for load()
+                load_kwargs = {
+                    d: loaded[d] for d in dep_step.loadDependsOn if d in loaded
+                }
+                try:
+                    loaded[name] = dep_step.load(**load_kwargs)
+                except FileNotFoundError:
+                    loaded[name] = None
+                return loaded[name]
+
+            # Create the target step
+            step_config = config.get(step_name, {}).copy()
+            step_config["plot"] = plot
             step_class = step_classes[step_name]
             step = step_class(
                 inst,
@@ -380,7 +447,17 @@ def make_step_command(step_name):
                 order_range=None,
                 **step_config,
             )
-            step.run(files=np.array([file]), mask=None, bias=None)
+
+            # Load all dependencies
+            loaded = {}
+            for dep in step.dependsOn:
+                load_dependency(dep, loaded)
+
+            # Build kwargs for run()
+            run_kwargs = {d: loaded.get(d) for d in step.dependsOn}
+            run_kwargs["files"] = np.array([file])
+
+            step.run(**run_kwargs)
         else:
             config = get_configuration_for_instrument(instrument)
             if settings:

pyreduce/clib/build_extract.py

@@ -1,75 +1,80 @@
 #!/usr/bin/env python3
-"""Builds the C library that contains the extraction algorithm
+"""Build script for CFFI C extensions (development only).
 
-This module prepares and builds the C libary containing the curved
-(and vertical) extraction algorithm using CFFI.
-It also prepares the ffibuilder objects for setup.py,
-so that the library is compiled on installation.
+Usage:
+    uv run reduce-build    # compile extensions
+    uv run reduce-clean    # remove compiled files
 
-
-The user can also call the Module as a script to compile the
-C libraries again.
-
-Attributes
-----------
-ffi_builder_vertical : FFI
-    CFFI Builder for the vertical extraction algorithm
-ffi_builder_curved : FFI
-    CFFI Builder for the curved extraction algorithm
+This compiles the C extraction libraries in-place for development.
+For production, extensions are built automatically during wheel creation
+via hatch_build.py.
 """
 
-import logging
+import glob
 import os
 
 from cffi import FFI
 
-logger = logging.getLogger(__name__)
-
-
 CWD = os.path.dirname(__file__)
 CWD = os.path.abspath(CWD)
 release_path = os.path.join(CWD, "Release")
 
-print("Include dir: ", CWD)
-print("Release dir: ", release_path)
-
 
-ffibuilder_vertical = FFI()
-with open(os.path.join(CWD, "slit_func_bd.h")) as f:
-    ffibuilder_vertical.cdef(f.read())
-with open(os.path.join(CWD, "slit_func_bd.c")) as f:
-    ffibuilder_vertical.set_source(
-        "_slitfunc_bd",
-        f.read(),
-        include_dirs=[CWD, release_path],
-        depends=["slit_func_bd.h"],
-    )
-
-ffibuilder_curved = FFI()
-with open(os.path.join(CWD, "slit_func_2d_xi_zeta_bd.h")) as f:
-    ffibuilder_curved.cdef(f.read())
-with open(os.path.join(CWD, "slit_func_2d_xi_zeta_bd.c")) as f:
-    ffibuilder_curved.set_source(
-        "_slitfunc_2d",
-        f.read(),
-        include_dirs=[CWD, release_path],
-        depends=["slit_func_2d_xi_zeta_bd.h"],
-    )
+def clean():
+    """Remove compiled extension files."""
+    patterns = ["*.so", "*.o", "*.pyd"]
+    removed = []
+    for pattern in patterns:
+        for f in glob.glob(os.path.join(CWD, pattern)):
+            os.remove(f)
+            removed.append(os.path.basename(f))
+    if removed:
+        print(f"Removed: {', '.join(removed)}")
+    else:
+        print("Nothing to clean.")
 
 
 def build():
-    """Builds the C slitfunc library"""
-    logger.info("Building required C libraries, this might take a few seconds")
+    """Build the C slitfunc libraries in-place."""
+    print("Building CFFI extensions for development...")
+    print(f"  Source dir: {CWD}")
 
     old_cwd = os.getcwd()
-    path = os.path.abspath(CWD)
-    os.chdir(path)
-
-    ffibuilder_vertical.compile(verbose=True, debug=False)
-    ffibuilder_curved.compile(verbose=True, debug=False)
-
-    os.chdir(old_cwd)
-
-
-if __name__ == "__main__":  # pragma: no cover
+    os.chdir(CWD)
+
+    try:
+        # Vertical extraction
+        ffibuilder_vertical = FFI()
+        with open("slit_func_bd.h") as f:
+            ffibuilder_vertical.cdef(f.read())
+        with open("slit_func_bd.c") as f:
+            ffibuilder_vertical.set_source(
+                "_slitfunc_bd",
+                f.read(),
+                include_dirs=[CWD, release_path],
+                depends=["slit_func_bd.h"],
+            )
+        ffibuilder_vertical.compile(verbose=True)
+        print("[OK] _slitfunc_bd")
+
+        # Curved extraction
+        ffibuilder_curved = FFI()
+        with open("slit_func_2d_xi_zeta_bd.h") as f:
+            ffibuilder_curved.cdef(f.read())
+        with open("slit_func_2d_xi_zeta_bd.c") as f:
+            ffibuilder_curved.set_source(
+                "_slitfunc_2d",
+                f.read(),
+                include_dirs=[CWD, release_path],
+                depends=["slit_func_2d_xi_zeta_bd.h"],
+            )
+        ffibuilder_curved.compile(verbose=True)
+        print("[OK] _slitfunc_2d")
+
+        print("Done.")
+    finally:
+        os.chdir(old_cwd)
+
+
+if __name__ == "__main__":
     build()

pyreduce/cwrappers.py

@@ -14,23 +14,9 @@ from scipy.ndimage import median_filter
 
 logger = logging.getLogger(__name__)
 
-try:
-    from .clib._slitfunc_2d import ffi
-    from .clib._slitfunc_2d import lib as slitfunc_2dlib
-    from .clib._slitfunc_bd import lib as slitfunclib
-except ImportError:  # pragma: no cover
-    logger.error(
-        "C libraries could not be found. Compiling them by running build_extract.py"
-    )
-    from .clib import build_extract
-
-    build_extract.build()
-    del build_extract
-
-    from .clib._slitfunc_2d import ffi
-    from .clib._slitfunc_2d import lib as slitfunc_2dlib
-    from .clib._slitfunc_bd import lib as slitfunclib
-
+from .clib._slitfunc_2d import ffi
+from .clib._slitfunc_2d import lib as slitfunc_2dlib
+from .clib._slitfunc_bd import lib as slitfunclib
 
 c_double = ctypes.c_double
 c_int = ctypes.c_int
@@ -129,7 +115,7 @@ def slitfunc(img, ycen, lambda_sp=0, lambda_sf=0.1, osample=1):
 
 
 def slitfunc_curved(
-    img, ycen, tilt, shear, lambda_sp, lambda_sf, osample, yrange, maxiter=20, gain=1
+    img, ycen, p1, p2, lambda_sp, lambda_sf, osample, yrange, maxiter=20, gain=1
 ):
     """Decompose an image into a spectrum and a slitfunction, image may be curved
 
@@ -139,10 +125,10 @@ def slitfunc_curved(
         input image
     ycen : array[n]
         traces the center of the order
-    tilt : array[n]
-        tilt (1st order curvature) of the order along the image, set to 0 if order straight
-    shear : array[n]
-        shear (2nd order curvature) of the order along the image, set to 0 if order straight
+    p1 : array[n]
+        1st order curvature of the order along the image, set to 0 if order straight
+    p2 : array[n]
+        2nd order curvature of the order along the image, set to 0 if order straight
     osample : int
         Subpixel ovsersampling factor (the default is 1, no oversampling)
     lambda_sp : float
@@ -175,23 +161,23 @@ def slitfunc_curved(
     assert ycen.ndim == 1, "Ycen must be 1 dimensional"
     assert maxiter > 0, "Maximum iterations must be positive"
 
-    if np.isscalar(tilt):
-        tilt = np.full(img.shape[1], tilt, dtype=c_double)
+    if np.isscalar(p1):
+        p1 = np.full(img.shape[1], p1, dtype=c_double)
     else:
-        tilt = np.asarray(tilt, dtype=c_double)
-    if np.isscalar(shear):
-        shear = np.full(img.shape[1], shear, dtype=c_double)
+        p1 = np.asarray(p1, dtype=c_double)
+    if np.isscalar(p2):
+        p2 = np.full(img.shape[1], p2, dtype=c_double)
     else:
-        shear = np.asarray(shear, dtype=c_double)
+        p2 = np.asarray(p2, dtype=c_double)
 
     assert img.shape[1] == ycen.size, (
         f"Image and Ycen shapes are incompatible, got {img.shape} and {ycen.shape}"
     )
-    assert img.shape[1] == tilt.size, (
-        f"Image and Tilt shapes are incompatible, got {img.shape} and {tilt.shape}"
+    assert img.shape[1] == p1.size, (
+        f"Image and p1 shapes are incompatible, got {img.shape} and {p1.shape}"
     )
-    assert img.shape[1] == shear.size, (
-        f"Image and Shear shapes are incompatible, got {img.shape} and {shear.shape}"
+    assert img.shape[1] == p2.size, (
+        f"Image and p2 shapes are incompatible, got {img.shape} and {p2.shape}"
     )
 
     assert osample > 0, f"Oversample rate must be positive, but got {osample}"
@@ -202,8 +188,8 @@ def slitfunc_curved(
 
     # assert np.ma.all(np.isfinite(img)), "All values in the image must be finite"
     assert np.all(np.isfinite(ycen)), "All values in ycen must be finite"
-    assert np.all(np.isfinite(tilt)), "All values in tilt must be finite"
-    assert np.all(np.isfinite(shear)), "All values in shear must be finite"
+    assert np.all(np.isfinite(p1)), "All values in p1 must be finite"
+    assert np.all(np.isfinite(p2)), "All values in p2 must be finite"
 
     assert yrange.ndim == 1, "Yrange must be 1 dimensional"
     assert yrange.size == 2, "Yrange must have 2 elements"
@@ -251,8 +237,8 @@ def slitfunc_curved(
     pix_unc[pix_unc < 1] = 1
 
     psf_curve = np.zeros((ncols, 3), dtype=c_double)
-    psf_curve[:, 1] = tilt
-    psf_curve[:, 2] = shear
+    psf_curve[:, 1] = p1
+    psf_curve[:, 2] = p2
 
     # Initialize arrays and ensure the correct datatype for C
     requirements = ["C", "A", "W", "O"]
@@ -333,8 +319,8 @@ def xi_zeta_tensors(
     ycen: np.ndarray,
     yrange,  # (int, int)
     osample: int,
-    tilt: np.ndarray,
-    shear: np.ndarray,
+    p1: np.ndarray,
+    p2: np.ndarray,
 ):
     ncols = int(ncols)
     nrows = int(nrows)
@@ -346,8 +332,8 @@ def xi_zeta_tensors(
     y_lower_lim = int(yrange[0])
 
     psf_curve = np.zeros((ncols, 3), dtype=c_double)
-    psf_curve[:, 1] = tilt
-    psf_curve[:, 2] = shear
+    psf_curve[:, 1] = p1
+    psf_curve[:, 2] = p2
 
     requirements = ["C", "A", "W", "O"]
     ycen_int = np.require(ycen_int, dtype=c_double, requirements=requirements)