nabu 2024.1.0rc3__py3-none-any.whl → 2024.1.1__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/doc/conf.py

@@ -0,0 +1,137 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath("../"))
+
+
+# -- Project information -----------------------------------------------------
+
+project = "Nabu"
+copyright = "2019-2024, ESRF"
+author = "Pierre Paleo"
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "myst_parser",
+    "sphinx.ext.autosectionlabel",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.mathjax",
+    "sphinx.ext.viewcode",
+    "nbsphinx",
+    #    'sphinx.ext.autosummary',
+    #    'sphinx.ext.doctest',
+    #    'sphinx.ext.inheritance_diagram',
+]
+# myst_commonmark_only = True
+# for myst
+suppress_warnings = [
+    "myst.header",  # non-consecutive headers levels
+    "autosectionlabel.*",  # duplicate section names
+]
+myst_heading_anchors = 3
+myst_enable_extensions = [
+    #    "amsmath",
+    # #   "colon_fence",
+    # #   "deflist",
+    "dollarmath",
+    #    "html_admonition",
+    #    "html_image",
+    #    "linkify",
+    # #   "replacements",
+    # #   "smartquotes",
+    # #   "substitution"
+]
+#
+# autosummary_generate = True
+autodoc_member_order = "bysource"
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+
+# from corlab_theme import get_theme_dir
+# html_theme = 'corlab_theme'
+
+from cloud_sptheme import get_theme_dir
+
+html_theme = "cloud"
+
+html_theme_path = [get_theme_dir()]
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ["_static"]
+# These paths are either relative to html_static_path
+# or fully qualified paths (eg. https://...)
+html_css_files = [
+    "theme_overrides.css",
+]
+
+html_theme_options = {
+    #    'navigation_depth': -1,
+    "max_width": "75%",
+    "minimal_width": "720px",
+}
+
+
+# For mathjax
+mathjax_path = "javascript/MathJax-3.0.5/es5/tex-mml-chtml.js"
+
+
+"""
+# For recommonmark
+from recommonmark.transform import AutoStructify
+github_doc_root = 'https://github.com/rtfd/recommonmark/tree/master/doc/'
+def setup(app):
+    app.add_config_value('recommonmark_config', {
+            'url_resolver': lambda url: github_doc_root + url,
+            'auto_toc_tree_section': 'Contents',
+            'enable_math': True,
+            'enable_inline_math': True,
+            }, True)
+    app.add_transform(AutoStructify)
+"""
+
+# Document __init__
+autoclass_content = "both"
+
+from nabu import __version__
+
+version = __version__
+release = version
+
+master_doc = "index"
+
+#
+# nbsphinx
+#
+
+nbsphinx_allow_errors = True

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

@@ -0,0 +1,38 @@
+#!/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/doc/get_mathjax.py

@@ -0,0 +1,34 @@
+#!/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/nabu/__init__.py

@@ -0,0 +1,17 @@
+__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/nabu/app/bootstrap.py

@@ -0,0 +1,88 @@
+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/nabu/app/bootstrap_stitching.py

@@ -0,0 +1,69 @@
+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/nabu/app/cast_volume.py

@@ -0,0 +1,272 @@
+#!/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)