pyreduce-astro 0.6.0b5__cp312-cp312-macosx_11_0_arm64.whl

pyreduce/__init__.py

@@ -0,0 +1,67 @@
+try:
+    from importlib.metadata import PackageNotFoundError, version
+except ImportError:  # for Python<3.8
+    from importlib_metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("pyreduce-astro")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+
+# add logger to console
+import logging
+
+import tqdm
+
+
+# We need to use this to have logging messages handle properly with the progressbar
+class TqdmLoggingHandler(logging.Handler):
+    def __init__(self, level=logging.NOTSET):
+        super().__init__(level)
+
+    def emit(self, record):
+        try:
+            msg = self.format(record)
+            tqdm.tqdm.write(msg)
+            self.flush()
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except:
+            self.handleError(record)
+
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+logging.captureWarnings(True)
+
+console = TqdmLoggingHandler()
+console.setLevel(logging.INFO)
+
+try:
+    import colorlog
+
+    console.setFormatter(
+        colorlog.ColoredFormatter("%(log_color)s%(levelname)s - %(message)s")
+    )
+    del colorlog
+except ImportError:
+    console.setFormatter("%(levelname)s - %(message)s")
+    print("Install colorlog for colored logging output")
+
+logger.addHandler(console)
+
+del logging
+# do not del tqdm, it is needed in the Log Handler
+
+
+# Lazy loading for faster imports
+def __getattr__(name):
+    """Lazy load submodules on first access."""
+    if name in ("configuration", "datasets", "reduce", "util"):
+        import importlib
+
+        module = importlib.import_module(f".{name}", __name__)
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

pyreduce/__main__.py

@@ -0,0 +1,106 @@
+"""
+This is used when pyreduce is used as a script
+"""
+
+import argparse
+import sys
+
+from .reduce import main
+from .tools.combine import combine as tools_combine
+
+scripts = ["reduce", "combine"]
+
+
+def help():
+    parser = argparse.ArgumentParser(
+        description="PyReduce script tools interface", prog="python -m pyreduce"
+    )
+    parser.add_argument("script", help="which script to execute", choices=scripts)
+    parser.print_help()
+
+
+def reduce():
+    parser = argparse.ArgumentParser(
+        description="PyReduce script tools interface", prog="python -m pyreduce"
+    )
+    parser.add_argument("script", help="which script to execute", choices=["reduce"])
+
+    parser.add_argument("-b", "--bias", action="store_true", help="Create master bias")
+    parser.add_argument("-f", "--flat", action="store_true", help="Create master flat")
+    parser.add_argument("-o", "--orders", action="store_true", help="Trace orders")
+    parser.add_argument("-n", "--norm_flat", action="store_true", help="Normalize flat")
+    parser.add_argument(
+        "-w", "--wavecal", action="store_true", help="Prepare wavelength calibration"
+    )
+    parser.add_argument(
+        "-s", "--science", action="store_true", help="Extract science spectrum"
+    )
+    parser.add_argument(
+        "-c", "--continuum", action="store_true", help="Normalize continuum"
+    )
+
+    parser.add_argument("instrument", type=str, help="instrument used")
+    parser.add_argument("target", type=str, help="target star")
+
+    args = parser.parse_args()
+    instrument = args.instrument.upper()
+    target = args.target.upper()
+
+    steps_to_take = {
+        "bias": args.bias,
+        "flat": args.flat,
+        "orders": args.orders,
+        "norm_flat": args.norm_flat,
+        "wavecal": args.wavecal,
+        "science": args.science,
+        "continuum": args.continuum,
+    }
+    steps_to_take = [k for k, v in steps_to_take.items() if v]
+
+    # if no steps are specified use all
+    if len(steps_to_take) == 0:
+        steps_to_take = "all"
+
+    main(instrument=instrument, target=target, steps=steps_to_take)
+
+
+def combine():
+    parser = argparse.ArgumentParser(
+        description="PyReduce script tools interface", prog="python -m pyreduce"
+    )
+    parser.add_argument("script", help="which script to execute", choices=["combine"])
+
+    parser.add_argument(
+        "--output", help="destination of the combined file", default="./combined.ech"
+    )
+    parser.add_argument(
+        "--plot", type=int, help="plot the results of the desired order"
+    )
+
+    parser.add_argument(
+        "input", nargs="+", help="input files to use", default="./*.final.ech"
+    )
+
+    args = parser.parse_args()
+
+    files = args.input
+    output = args.output
+    plot = args.plot
+
+    tools_combine(files, output, plot=plot)
+
+
+if __name__ == "__main__":
+    # Determine which script to run
+    if len(sys.argv) == 1:
+        script = "help"
+    else:
+        script = sys.argv[1]
+
+    # Run the chosen script
+    if script == "reduce":
+        reduce()
+    elif script == "combine":
+        combine()
+    else:
+        help()

pyreduce/clib/build_extract.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""Builds the C library that contains the extraction algorithm
+
+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.
+
+
+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
+"""
+
+import logging
+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 build():
+    """Builds the C slitfunc library"""
+    logger.info("Building required C libraries, this might take a few seconds")
+
+    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
+    build()