nabu 2024.1.1__py3-none-any.whl → 2024.1.2__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/doc/create_conf_doc.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python
-import os
-from nabu.pipeline.fullfield.nabu_config import nabu_config
-
-
-def header(file_):
-    content = "# Nabu configuration parameters\nThis file lists all the current configuration parameters available in the [configuration file](nabu_config_file.md)."
-    print(content, file=file_)
-
-def generate(file_):
-    def write(content):
-        print(content, file=file_)
-    header(file_)
-    for section, values in nabu_config.items():
-        if section == "about":
-            continue
-        write("### %s\n" % section)
-        for key, val in values.items():
-            if val["type"] == "unsupported":
-                continue
-            help_content = val["help"]
-            if "---" in help_content:
-                help_content = help_content.replace("--", "")
-            write(help_content + "\n")
-            write(
-                "```ini\n%s = %s\n```"
-                % (key, val["default"])
-            )
-
-
-
-if __name__ == "__main__":
-    fname = os.path.join(
-        os.path.dirname(os.path.realpath(__file__)),
-        "nabu_config_items.md"
-    )
-    with open(fname, "w") as f:
-        generate(f)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/doc/get_mathjax.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python
-import os
-import tarfile
-import requests
-
-MATHJAX_PATH = "_static/javascript/MathJax-3.0.5"
-MATHJAX_URL = "http://www.silx.org/pub/nabu/static/MathJax-3.0.5.tar.lzma"
-
-
-def download_file(file_url, target_file_path):
-    print("Downloading %s" % file_url)
-    rep = requests.get(file_url)
-    with open(target_file_path, "wb") as f:
-        f.write(rep.content)
-
-
-def uncompress_file(compressed_file_path, target_directory):
-    print("Uncompressing %s into %s" % (compressed_file_path, target_directory))
-    with tarfile.open(compressed_file_path) as f:
-        f.extractall(path=target_directory)
-
-
-def main():
-    doc_path = os.path.dirname(os.path.realpath(__file__))
-    mathjax_path = os.path.join(doc_path, MATHJAX_PATH)
-    if os.path.isdir(mathjax_path):
-        return
-    mathjax_comp_file = mathjax_path + ".tar.lzma"
-    download_file(MATHJAX_URL, mathjax_comp_file)
-    uncompress_file(mathjax_comp_file, os.path.dirname(mathjax_path))
-
-
-if __name__ == "__main__":
-    main()

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/__init__.py

@@ -1,17 +0,0 @@
-__version__ = "2024.1.1"
-__nabu_modules__ = [
-    "app",
-    "cuda",
-    "estimation",
-    "io",
-    "misc",
-    "opencl",
-    "pipeline",
-    "processing",
-    "preproc",
-    "reconstruction",
-    "resources",
-    "thirdparty",
-    "stitching",
-]
-version = __version__

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/bootstrap.py

@@ -1,88 +0,0 @@
-from os import path, environ
-from glob import glob
-from ..utils import get_folder_path
-from ..pipeline.config import generate_nabu_configfile, parse_nabu_config_file
-from ..pipeline.fullfield.nabu_config import nabu_config as default_fullfield_config
-from ..pipeline.helical.nabu_config import nabu_config as helical_fullfield_config
-from .utils import parse_params_values
-from .cli_configs import BootstrapConfig
-
-
-def bootstrap():
-    args = parse_params_values(BootstrapConfig, parser_description="Initialize a nabu configuration file")
-
-    do_bootstrap = bool(args["bootstrap"])
-    do_convert = args["convert"] != ""
-    no_comments = bool(args["nocomments"])
-
-    if do_bootstrap:
-        print(
-            "The --bootstrap option is now the default behavior of the nabu-config command. This option is therefore not needed anymore."
-        )
-
-    if path.isfile(args["output"]):
-        rep = input("File %s already exists. Overwrite ? [y/N]" % args["output"])
-        if rep.lower() != "y":
-            print("Stopping")
-            exit(0)
-
-    opts_level = args["level"]
-
-    prefilled_values = {}
-    template_name = args["template"]
-    if template_name != "":
-        prefilled_values = get_config_template(template_name, if_not_found="print")
-        if prefilled_values is None:
-            exit(0)
-        opts_level = "advanced"
-
-    if args["dataset"] != "":
-        prefilled_values["dataset"] = {}
-        user_dataset = args["dataset"]
-        if not path.isabs(user_dataset):
-            user_dataset = path.abspath(user_dataset)
-            print("Warning: using absolute dataset path %s" % user_dataset)
-        if not path.exists(user_dataset):
-            print("Error: cannot find the file or directory %s" % user_dataset)
-            exit(1)
-        prefilled_values["dataset"]["location"] = user_dataset
-
-    if args["helical"]:
-        my_config = helical_fullfield_config
-    else:
-        my_config = default_fullfield_config
-
-    generate_nabu_configfile(
-        args["output"],
-        my_config,
-        comments=not (no_comments),
-        options_level=opts_level,
-        prefilled_values=prefilled_values,
-    )
-    return 0
-
-
-def get_config_template(template_name, if_not_found="raise"):
-    def handle_not_found(msg):
-        if if_not_found == "raise":
-            raise FileNotFoundError(msg)
-        elif if_not_found == "print":
-            print(msg)
-
-    templates_path = get_folder_path(path.join("resources", "templates"))
-
-    custom_templates_path = environ.get("NABU_TEMPLATES_PATH", None)
-    templates = glob(path.join(templates_path, "*.conf"))
-    if custom_templates_path is not None:
-        templates_custom = glob(path.join(custom_templates_path, "*.conf"))
-        templates_custom += glob(path.join(custom_templates_path, "*.cfg"))
-        templates = templates_custom + templates
-
-    available_templates_names = [path.splitext(path.basename(fname))[0] for fname in templates]
-
-    if template_name not in available_templates_names:
-        handle_not_found("Unable to find template '%s'. Available are: %s" % (template_name, available_templates_names))
-        return
-
-    fname = templates[available_templates_names.index(template_name)]
-    return parse_nabu_config_file(fname)

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/bootstrap_stitching.py

@@ -1,69 +0,0 @@
-from .cli_configs import BootstrapStitchingConfig
-from ..pipeline.config import generate_nabu_configfile
-from ..stitching.config import (
-    get_default_stitching_config,
-    SECTIONS_COMMENTS as _SECTIONS_COMMENTS,
-    INPUT_DATASETS_FIELD as _INPUT_DATASETS_FIELD,
-    INPUTS_SECTION as _INPUTS_SECTION,
-)
-from .utils import parse_params_values
-from tomoscan.factory import Factory
-from tomoscan.esrf.volume.utils import guess_volumes
-
-
-def guess_tomo_objects(my_str: str) -> tuple:
-    """
-    try to find some tomo object from a string.
-    The string can be either related to a volume or a scan and can be an identifier or a filfe/folder path
-
-    :param str my_str: string related to the tomo object
-    :return: a tuple of tomo objects either instance of VolumeBase or TomoScanBase
-    :rtype: tuple
-    """
-    try:
-        # create_tomo_object_from_identifier will raise an exception is the string does not match an identifier
-        return (Factory.create_tomo_object_from_identifier(my_str),)
-    except Exception:
-        pass
-
-    try:
-        volumes = guess_volumes(my_str)
-    except Exception:
-        pass
-    else:
-        if len(volumes) > 0:
-            return volumes
-
-    try:
-        return Factory.create_scan_objects(my_str)
-    except Exception:
-        return tuple()
-
-
-def bootstrap_stitching():
-    args = parse_params_values(
-        BootstrapStitchingConfig,
-        parser_description="Initialize a 'nabu-stitching' configuration file",
-    )
-
-    prefilled_values = {}
-
-    datasets_as_str = args.get("datasets", None)
-    datasets = []
-    for dataset in datasets_as_str:
-        datasets.extend(guess_tomo_objects(dataset))
-
-    if len(datasets) > 0:
-        prefilled_values = {
-            _INPUTS_SECTION: {_INPUT_DATASETS_FIELD: [dataset.get_identifier().to_str() for dataset in datasets]}
-        }
-
-    generate_nabu_configfile(
-        fname=args["output"],
-        default_config=get_default_stitching_config(args["stitching_type"]),
-        comments=True,
-        sections_comments=_SECTIONS_COMMENTS,
-        options_level=args["level"],
-        prefilled_values=prefilled_values,
-    )
-    return 0

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/app/cast_volume.py

@@ -1,272 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import argparse
-import os
-import sys
-import logging
-from argparse import RawTextHelpFormatter
-import numpy
-from tomoscan.esrf.volume.utils import guess_volumes
-from tomoscan.factory import Factory
-from tomoscan.esrf.volume import (
-    EDFVolume,
-    HDF5Volume,
-    JP2KVolume,
-    MultiTIFFVolume,
-    TIFFVolume,
-)
-from nabu.io.cast_volume import (
-    RESCALE_MAX_PERCENTILE,
-    RESCALE_MIN_PERCENTILE,
-    cast_volume,
-    get_default_output_volume,
-)
-from nabu.pipeline.params import files_formats
-from nabu.utils import convert_str_to_tuple
-from nabu.io.cast_volume import _min_max_from_histo
-
-from silx.io.url import DataUrl
-
-_logger = logging.getLogger(__name__)
-
-
-def main(argv=None):
-    if argv is None:
-        argv = sys.argv
-    _volume_url_helps = "\n".join(
-        [
-            f"- {(volume.__name__).ljust(15)}: {volume.example_defined_from_str_identifier()}"
-            for volume in (
-                EDFVolume,
-                HDF5Volume,
-                JP2KVolume,
-                MultiTIFFVolume,
-                TIFFVolume,
-            )
-        ]
-    )
-
-    volume_help = f"""To define a volume you can either provide: \n
-    * an url (recommanded way) - see details lower \n
-    * a path. For hdf5 and multitiff we expect a file path. For edf, tif and jp2k we expect a folder path. In this case we will try to deduce the Volume from it. \n 
-    url must be defined like: \n{_volume_url_helps}
-    """
-
-    parser = argparse.ArgumentParser(description=__doc__, formatter_class=RawTextHelpFormatter)
-    parser.add_argument(
-        "input_volume",
-        help=f"input volume. {volume_help}",
-    )
-    parser.add_argument(
-        "--output-data-type",
-        help="output data type. Valid value are numpy default types name like (uint8, uint16, int8, int16, int32, float32, float64)",
-        default="uint16",
-    )
-    parser.add_argument(
-        "--output_volume",
-        help=f"output volume. Must be provided if 'output_type' isn't. Must looks like: \n{volume_help}",
-        default=None,
-    )
-    parser.add_argument(
-        "--output_type",
-        help=f"output type. Must be provided if 'output_volume' isn't. Valid values are {tuple(files_formats.keys())}",
-        default=None,
-    )
-    parser.add_argument(
-        "--data_min",
-        help=f"value to clamp to volume cast new min. Any lower value will also be clamp to this value.",
-        default=None,
-    )
-    parser.add_argument(
-        "--data_max",
-        help=f"value to clamp to volume cast new max. Any higher value will also be clamp to this value.",
-        default=None,
-    )
-    parser.add_argument(
-        "--rescale_min_percentile",
-        help=f"used to determine data_min if not provided. Expected as percentage. Default is {RESCALE_MIN_PERCENTILE}%%",
-        default=RESCALE_MIN_PERCENTILE,
-    )
-    parser.add_argument(
-        "--rescale_max_percentile",
-        help=f"used to determine data_max if not provided. Expected as percentage. Default is {RESCALE_MAX_PERCENTILE}%%",
-        default=RESCALE_MAX_PERCENTILE,
-    )
-    parser.add_argument(
-        "--overwrite",
-        dest="overwrite",
-        action="store_true",
-        default=False,
-        help="Overwrite file or dataset if exists",
-    )
-    parser.add_argument(
-        "--compression-ratios",
-        dest="compression_ratios",
-        default=None,
-        help="Define compression ratios for jp2k. Expected as a list like [20, 10, 1] for [quality layer 1, quality layer 2, quality layer 3]... Pass parameter to glymur. See https://glymur.readthedocs.io/en/latest/how_do_i.html#write-images-with-different-compression-ratios-for-different-layers for more details",
-    )
-    parser.add_argument(
-        "--histogram-url",
-        dest="histogram_url",
-        default=None,
-        help="Provide url to the histogram - like: '/{path}/my_file.hdf5?path/to/my/data' with my_file.hdf5 is the file containing the histogram. Located under 'path'. And 'path/to/my/data' is the location of the HDF5 dataset",
-    )
-
-    options = parser.parse_args(argv[1:])
-
-    # handle input volume
-    if os.path.exists(options.input_volume):
-        volumes = guess_volumes(options.input_volume)
-
-        def is_not_histogram(vol_identifier):
-            return not (hasattr(vol_identifier, "data_path") and vol_identifier.data_path.endswith("histogram"))
-
-        volumes = tuple(filter(is_not_histogram, volumes))
-        if len(volumes) == 0:
-            _logger.error(f"no valid volume found in {options.input_volume}")
-            exit(1)
-        elif len(volumes) > 1:
-            _logger.error(
-                f"found several volume from {options.input_volume}. Please provide one full url from {[volume.get_identifier() for volume in volumes]}"
-            )
-        else:
-            input_volume = volumes[0]
-    else:
-        try:
-            input_volume = Factory.create_tomo_object_from_identifier(options.input_volume)
-        except Exception as e:
-            raise ValueError(f"Fail to build input volume from url {options.input_volume}") from e
-
-    # handle output format
-    output_format = files_formats.get(options.output_type, None)
-
-    # handle output volume
-    if options.output_volume is not None:
-        # if an url is provided
-        if ":" in options.output_volume:
-            try:
-                output_volume = Factory.create_tomo_object_from_identifier(options.output_volume)
-            except Exception as e:
-                raise ValueError(f"Fail to build output volume from {options.output_volume}") from e
-
-            if output_format is not None:
-                if not (
-                    isinstance(output_volume, EDFVolume)
-                    and output_format == "edf"
-                    or isinstance(output_format, HDF5Volume)
-                    and output_format == "hdf5"
-                    or isinstance(output_format, JP2KVolume)
-                    and output_format == "jp2"
-                    or isinstance(output_format, (TIFFVolume, MultiTIFFVolume))
-                    and output_format == "tiff"
-                ):
-                    raise ValueError(
-                        "Requested 'output_type' and output volume url are incoherent. 'output_type' is optional when url provided"
-                    )
-        else:
-            path_extension = os.path.splitext(options.output_volume)[-1]
-            if path_extension == "":
-                # if a folder ha sbeen provided we try to create a volume from this path and the output format
-                if output_format == "tiff":
-                    output_volume = TIFFVolume(
-                        folder=options.output_volume,
-                    )
-                elif output_format == "edf":
-                    output_volume = EDFVolume(
-                        folder=options.output_volume,
-                    )
-                elif output_format == "jp2":
-                    output_volume = JP2KVolume(
-                        folder=options.output_volume,
-                    )
-                else:
-                    raise ValueError(
-                        f"Unable to deduce an output volume from {options.output_volume} and output format {output_format}. Please provide an output_volume as an url"
-                    )
-            else:
-                # if a file path_has been provided
-                if path_extension.lower() in ("tif", "tiff") and output_format in (
-                    None,
-                    "tiff",
-                ):
-                    output_volume = MultiTIFFVolume(
-                        file_path=options.output_volume,
-                    )
-                elif path_extension.lower() in (
-                    "h5",
-                    "nx",
-                    "nexus",
-                    "hdf",
-                    "hdf5",
-                ) and output_format in (None, "hdf5"):
-                    output_volume = HDF5Volume(
-                        file_path=options.output_volume,
-                        data_path="volume",
-                    )
-                else:
-                    raise ValueError(
-                        f"Unable to deduce an output volume from {options.output_volume} and output format {output_format}. Please provide an output_volume as an url"
-                    )
-
-    elif options.output_type is None:
-        raise ValueError("'output_type' or 'output_volume' is expected")
-    else:
-        output_volume = get_default_output_volume(input_volume=input_volume, output_type=output_format)
-    try:
-        output_data_type = numpy.dtype(getattr(numpy, options.output_data_type))
-    except Exception as e:
-        raise ValueError(f"Unable to get output data type from {options.output_data_type}") from e
-
-    # get data_min and data_max
-    data_min = options.data_min
-    if data_min is not None:
-        data_min = float(data_min)
-    data_max = options.data_max
-    if data_max is not None:
-        data_max = float(data_max)
-
-    # get rescale_min_percentile and rescale_min_percentile
-    rescale_min_percentile = options.rescale_min_percentile
-    if isinstance(rescale_min_percentile, str):
-        rescale_min_percentile = float(rescale_min_percentile.rstrip("%"))
-    rescale_max_percentile = options.rescale_max_percentile
-    if isinstance(rescale_min_percentile, str):
-        rescale_max_percentile = float(rescale_max_percentile.rstrip("%"))
-    assert rescale_min_percentile is not None, "rescale_min_percentile should be an int"
-    assert rescale_max_percentile is not None, "rescale_max_percentile should be an int"
-
-    # handle histogram and data_min, data_max
-    if options.histogram_url is not None:
-        if data_min is not None or data_max is not None:
-            raise ValueError("Both histogram url and data min/max are provided. Don't know which one to take")
-        else:
-            if not options.histogram_url.startswith("silx:"):
-                options.histogram_url = "silx:" + options.histogram_url
-            histogram_url = DataUrl(path=options.histogram_url)
-            data_min, data_max = _min_max_from_histo(
-                url=histogram_url,
-                rescale_min_percentile=rescale_min_percentile,
-                rescale_max_percentile=rescale_max_percentile,
-            )
-
-    # update output volume from options
-    output_volume.overwrite = options.overwrite
-    if options.compression_ratios is not None:
-        output_volume.cratios = list([int(value) for value in convert_str_to_tuple(options.compression_ratios)])
-
-    # do volume casting
-    cast_volume(
-        input_volume=input_volume,
-        output_volume=output_volume,
-        output_data_type=output_data_type,
-        data_min=data_min,
-        data_max=data_max,
-        rescale_min_percentile=rescale_min_percentile,
-        rescale_max_percentile=rescale_max_percentile,
-    )
-    exit(0)
-
-
-if __name__ == "__main__":
-    main(sys.argv)