lls-core 1.0.0__tar.gz

lls_core-1.0.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.1
+Name: lls_core
+Version: 1.0.0
+Summary: Core functionality for analysing and visualizing lattice lightsheet and Oblique Plane Microscopy data.
+Author: Pradeep Rajasekhar, Lachlan Whitehead, Robert Haase, Michael Milton
+License: GPL-3.0-only
+Project-URL: Repository, https://github.com/BioimageAnalysisCoreWEHI/napari_lattice
+Project-URL: BugTracker, https://github.com/BioimageAnalysisCoreWEHI/napari_lattice/issues
+Project-URL: Documentation, https://github.com/BioimageAnalysisCoreWEHI/napari_lattice/wiki
+Project-URL: SourceCode, https://github.com/BioimageAnalysisCoreWEHI/napari_lattice
+Project-URL: UserSupport, https://github.com/BioimageAnalysisCoreWEHI/napari_lattice/issues
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Framework :: napari
+Classifier: Topic :: Software Development :: Testing
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: aicsimageio>=4.6.3
+Requires-Dist: aicspylibczi>=3.1.1
+Requires-Dist: click
+Requires-Dist: dask
+Requires-Dist: dask[distributed]
+Requires-Dist: fsspec>=2022.8.2
+Requires-Dist: importlib_resources
+Requires-Dist: napari-workflows>=0.2.8
+Requires-Dist: npy2bdv
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: pyclesperanto_prototype>=0.20.0
+Requires-Dist: pyopencl
+Requires-Dist: pydantic<3,>=1.10.17
+Requires-Dist: pyyaml
+Requires-Dist: read-roi
+Requires-Dist: rich
+Requires-Dist: resource-backed-dask-array>=0.1.0
+Requires-Dist: scikit-image
+Requires-Dist: StrEnum
+Requires-Dist: tifffile>=2023.3.15
+Requires-Dist: toolz
+Requires-Dist: tqdm
+Requires-Dist: typer
+Requires-Dist: typing_extensions>=4.7.0
+Requires-Dist: xarray[parallel]
+Provides-Extra: testing
+Requires-Dist: tox; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: napari; extra == "testing"
+Provides-Extra: deconvolution
+Requires-Dist: pycudadecon~=0.5; extra == "deconvolution"
+Requires-Dist: numpy<2; extra == "deconvolution"
+Provides-Extra: docs
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+Requires-Dist: mkdocs-click; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: fieldz>=0.1.0; extra == "docs"
+Requires-Dist: griffe-fieldz; extra == "docs"
+Provides-Extra: deploy
+Requires-Dist: build; extra == "deploy"
+Requires-Dist: twine; extra == "deploy"

lls_core-1.0.0/lls_core/__init__.py

@@ -0,0 +1,55 @@
+
+__version__ = "0.2.6"
+
+from strenum import StrEnum
+from enum import Enum
+from pyclesperanto_prototype._tier8._affine_transform_deskew_3d import DeskewDirection
+from lls_core.models.lattice_data import LatticeData
+from lls_core.models.deconvolution import DeconvolutionParams
+from lls_core.models.lattice_data import CropParams
+
+# Initialize configuration options
+
+#CONFIGURE LOGGING using a dictionary (can also be done with yaml file)
+import logging.config
+LOGGING_CONFIG = {
+    'version': 1,
+    'disable_existing_loggers': False,
+
+    'formatters': {
+        'default_formatter': {
+            'format': '[%(levelname)s:%(asctime)s] %(message)s'
+        },
+    },
+
+    'handlers': {
+        'stream_handler': {
+            'class': 'logging.StreamHandler',
+            'formatter': 'default_formatter',
+        },
+    },
+
+    'loggers': {
+        '': {
+            'handlers': ['stream_handler'],
+            'level': 'INFO',
+            'propagate': True
+        }
+    }
+}
+
+#Configuring logging level with empty string "" under the key loggers means its for root
+#This will override levels for all other python libraries as they haven't been imported yet
+#Specifying levels in each modules will override the root level
+
+# Specify during initialization:
+logging.config.dictConfig(LOGGING_CONFIG)
+logger = logging.getLogger(__name__)
+logger.debug("Logging is configured.")
+
+#specify an enum for log levels
+class Log_Levels(Enum):
+    DEBUG = 10
+    INFO = 20
+    WARNING = 30
+    

lls_core-1.0.0/lls_core/cmds/__init__.py

@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+

lls_core-1.0.0/lls_core/cmds/__main__.py

@@ -0,0 +1,234 @@
+# lattice_processing.py
+
+# Run processing on command line instead of napari.
+# Example for deskewing files in a folder
+# python lattice_processing.py --input /home/pradeep/to_deskew --output /home/pradeep/output_save/ --processing deskew
+from __future__ import annotations
+
+from enum import auto
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Optional, Tuple, Union
+from strenum import StrEnum
+
+from lls_core.models.lattice_data import LatticeData
+from lls_core.models.deskew import DeskewParams, DefinedPixelSizes
+from lls_core.models.deconvolution import DeconvolutionParams
+from lls_core.models.output import OutputParams
+from lls_core.models.crop import CropParams
+from lls_core.deconvolution import DeconvolutionChoice
+from typer import Typer, Argument, Option, Context, Exit
+from typer.main import get_command
+
+from lls_core.models.output import SaveFileType
+from pydantic.v1 import ValidationError
+from toolz.dicttoolz import merge_with
+
+if TYPE_CHECKING:
+    from lls_core.models.utils import FieldAccessModel
+    from typing import Type, Any, Iterable
+    from rich.table import Table
+
+class CliDeskewDirection(StrEnum):
+    X = auto()
+    Y = auto()
+
+CLI_PARAM_MAP = {
+    "input_image": ["input_image"],
+    "angle": ["angle"],
+    "skew": ["skew"],
+    "physical_pixel_sizes": ["physical_pixel_sizes"],
+    "roi_list": ["crop", "roi_list"],
+    "roi_subset": ["crop", "roi_subset"],
+    "z_range": ["crop", "z_range"],
+    "decon_processing": ["deconvolution", "decon_processing"],
+    "psf": ["deconvolution", "psf"],
+    "decon_num_iter": ["deconvolution", "decon_num_iter"],
+    "background": ["deconvolution", "background"],
+    "workflow": ["workflow"],
+    "time_range": ["time_range"],
+    "channel_range": ["channel_range"],
+    "save_dir": ["save_dir"],
+    "save_name": ["save_name"],
+    "save_type": ["save_type"],
+}
+
+app = Typer(add_completion=False, rich_markup_mode="rich", no_args_is_help=True)
+
+def field_from_model(model: Type[FieldAccessModel], field_name: str, extra_description: str = "", description: Optional[str] = None, default: Optional[Any] = None, **kwargs) -> Any:
+    """
+    Generates a type Field from a Pydantic model field
+    """
+    field = model.__fields__[field_name]
+
+    from enum import Enum
+    if default is None:
+        default = field.get_default()
+    if isinstance(default, Enum):
+        default = default.name
+
+    if description is None:
+        description = f"{field.field_info.description} {extra_description}"
+
+    return Option(
+        default = default,
+        help=description,
+        **kwargs
+    )
+
+def handle_merge(values: list):
+    if len(values) > 1:
+        if all(isinstance(param, dict) for param in values):
+            return merge_with(handle_merge, values)
+        else:
+            raise ValueError(f"A parameter has been passed multiple times! Got: {', '.join(values)}")
+    return values[0]
+
+def rich_validation(e: ValidationError) -> Table:
+    """
+    Converts 
+    """
+    from rich.table import Table
+
+    table = Table(title="Validation Errors")
+    table.add_column("Parameter")
+    # table.add_column("Command Line Argument")
+    table.add_column("Error")
+
+    for error in e.errors():
+        table.add_row(
+            str(error["loc"][0]),
+            str(error["msg"]),
+        )
+
+    return table
+
+def pairwise(iterable: Iterable) -> Iterable:
+    """
+    An implementation of the pairwise() function in Python 3.10+
+    See: https://docs.python.org/3.12/library/itertools.html#itertools.pairwise
+    """
+    from itertools import tee
+    a, b = tee(iterable)
+    next(b, None)
+    return zip(a, b)
+
+def update_nested_data(data: Union[dict, list], keys: list, new_value: Any):
+    current = data
+
+    for key, next_key in pairwise(keys):
+        next = {} if isinstance(next_key, str) else []
+        if isinstance(current, dict):
+            current = current.setdefault(key, next)
+        elif isinstance(current, list):
+            if key >= len(current):
+                current.insert(key, next)
+            current = current[key]
+        else:
+            raise ValueError(f"Unknown data type {type(current)}. Cannot traverse.")
+
+    last_key = keys[-1]
+    if isinstance(current, dict):
+        current[last_key] = new_value
+    elif isinstance(current, list):
+        current.insert(last_key, new_value)
+    else:
+        raise ValueError(f"Unknown data type {type(current)}. Cannot traverse.")
+
+# Example usage:
+@app.command()
+def process(
+    ctx: Context,
+    input_image: Path = Argument(None, help="Path to the image file to read, in a format readable by AICSImageIO, for example .tiff or .czi", show_default=False),
+    skew: CliDeskewDirection = field_from_model(DeskewParams, "skew"),# DeskewParams.make_typer_field("skew"),
+    angle: float = field_from_model(DeskewParams, "angle") ,
+    physical_pixel_sizes: Tuple[float, float, float] = field_from_model(DeskewParams, "physical_pixel_sizes", extra_description="This takes three arguments, corresponding to the Z, Y and X pixel dimensions respectively", default=(
+        DefinedPixelSizes.get_default("Z"),
+        DefinedPixelSizes.get_default("Y"),
+        DefinedPixelSizes.get_default("X")
+    )),
+
+    roi_list: List[Path] = field_from_model(CropParams, "roi_list"), 
+    roi_subset: List[int] = field_from_model(CropParams, "roi_subset"),
+    z_range: Optional[Tuple[int,int]] = field_from_model(CropParams, "z_range", show_default=False),
+    
+    enable_deconvolution: bool = Option(False, "--deconvolution/--disable-deconvolution", rich_help_panel="Deconvolution"),
+    decon_processing: DeconvolutionChoice = field_from_model(DeconvolutionParams, "decon_processing", rich_help_panel="Deconvolution"),
+    psf: List[Path] = field_from_model(DeconvolutionParams, "psf", rich_help_panel="Deconvolution"),
+    decon_num_iter: int = field_from_model(DeconvolutionParams, "decon_num_iter", rich_help_panel="Deconvolution"),
+    background: str = field_from_model(DeconvolutionParams, "background", rich_help_panel="Deconvolution"),
+
+    time_range: Optional[Tuple[int,int]] = field_from_model(OutputParams, "time_range", rich_help_panel="Output"),
+    channel_range: Optional[Tuple[int,int]] = field_from_model(OutputParams,"channel_range", rich_help_panel="Output"),
+        
+    save_dir: Path = field_from_model(OutputParams, "save_dir", rich_help_panel="Output"),
+    save_name: Optional[str] = field_from_model(OutputParams, "save_name", rich_help_panel="Output"),
+    save_type: SaveFileType = field_from_model(OutputParams, "save_type", rich_help_panel="Output"),
+
+    workflow: Optional[Path] = field_from_model(LatticeData, "workflow", show_default=False),
+    json_config: Optional[Path] = Option(None, show_default=False, help="Path to a JSON file from which parameters will be read."),
+    yaml_config: Optional[Path] = Option(None, show_default=False, help="Path to a YAML file from which parameters will be read."),
+
+    show_schema: bool = Option(default=False, help="If provided, image processing will not be performed, and instead a JSON document outlining the JSON/YAML options will be printed to stdout. This can be used to assist with writing a config file for use with the --json-config and --yaml-config options.")
+) -> None:
+    from click.core import ParameterSource
+    from rich.console import Console
+
+    console = Console(stderr=True)
+
+    if show_schema:
+        import json
+        import sys
+        json.dump(
+            LatticeData.to_definition_dict(),
+            sys.stdout,
+            indent=4
+        )
+        return
+
+    # Just print help if the user didn't provide any arguments
+    if all(src != ParameterSource.COMMANDLINE for src in ctx._parameter_source.values()):
+        print(ctx.get_help())
+        raise Exit()
+
+    from toolz.dicttoolz import merge_with
+    cli_args = {}
+    for source, dest in CLI_PARAM_MAP.items():
+        from click.core import ParameterSource
+        if ctx.get_parameter_source(source) != ParameterSource.DEFAULT:
+            update_nested_data(cli_args, dest, ctx.params[source])
+
+    json_args = {}
+    if json_config is not None:
+        import json
+        with json_config.open() as fp:
+            json_args = json.load(fp)
+
+    yaml_args = {}
+    if yaml_config is not None:
+        with yaml_config.open() as fp:
+            from yaml import safe_load
+            yaml_args = safe_load(fp)
+
+    try:
+        lattice = LatticeData.parse_obj(
+            # Merge all three sources of config: YAML, JSON and CLI
+            merge_with(
+                handle_merge,
+                [yaml_args, json_args, cli_args]
+            )
+        )
+    except ValidationError as e:
+        console.print(rich_validation(e))
+        raise Exit(code=1)
+    
+    lattice.save()
+    console.print(f"Processing successful. Results can be found in {lattice.save_dir.resolve()}")
+
+# Used by the docs
+click_app = get_command(app)
+
+def main():
+    app()
+
+if __name__ == '__main__':
+    main()

lls_core-1.0.0/lls_core/config.py

@@ -0,0 +1,6 @@
+#module for accessing variables across modules in workflow
+#https://docs.python.org/3/faq/programming.html?highlight=global#how-do-i-share-global-variables-across-modules
+channel = 0
+time = 0 
+#configure default logging level for use in packages; inherit from dock_widget or __main__.py
+log_level = 10

lls_core-1.0.0/lls_core/cropping.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, NamedTuple, Tuple, List
+
+if TYPE_CHECKING:
+    from lls_core.types import PathLike
+    from typing_extensions import Self
+    from numpy.typing import NDArray
+
+RoiCoord = Tuple[float, float]
+
+class Roi(NamedTuple):
+    top_left: RoiCoord
+    top_right: RoiCoord
+    bottom_left: RoiCoord
+    bottom_right: RoiCoord
+
+    @classmethod
+    def from_array(cls, array: NDArray) -> Self:
+        import numpy as np
+        return Roi(*np.reshape(array, (-1, 2)).tolist())
+
+def read_roi_array(roi: PathLike) -> NDArray:
+    from read_roi import read_roi_file
+    from numpy import array
+    return array(read_roi_file(str(roi)))
+
+def read_imagej_roi(roi_path: PathLike) -> List[Roi]:
+    """Read an ImageJ ROI zip file so it loaded into napari shapes layer
+        If non rectangular ROI, will convert into a rectangle based on extreme points
+    Args:
+        roi_zip_path (zip file): ImageJ ROI zip file
+
+    Returns:
+        list: List of ROIs
+    """
+    from pathlib import Path
+    from os import fspath
+    from read_roi import read_roi_file, read_roi_zip
+
+    roi_path = Path(fspath(roi_path))
+
+    # handle reading single roi or collection of rois in zip file
+    if roi_path.suffix == ".zip":
+        ij_roi = read_roi_zip(roi_path)
+    elif roi_path.suffix == ".roi":
+        ij_roi = read_roi_file(str(roi_path))
+    else:
+        raise Exception("ImageJ ROI file needs to be a zip/roi file")
+
+    if ij_roi is None:
+        raise Exception("Failed reading ROI file")
+
+    # initialise list of rois
+    roi_list = []
+
+    # Read through each roi and create a list so that it matches the organisation of the shapes from napari shapes layer
+    for value in ij_roi.values():
+        if value['type'] in ('oval', 'rectangle'):
+            width = int(value['width'])
+            height = int(value['height'])
+            left = int(value['left'])
+            top = int(value['top'])
+            roi = Roi((top, left), (top, left+width), (top+height, left+width), (top+height, left))
+            roi_list.append(roi)
+        elif value['type'] in ('polygon', 'freehand'):
+            left = min(int(it) for it in value['x'])
+            top = min(int(it) for it in value['y'])
+            right = max(int(it) for it in value['x'])
+            bottom = max(int(it) for it in value['y'])
+            roi = Roi((top, left), (top, right), (bottom, right), (bottom, left))
+            roi_list.append(roi)
+        else:
+            print(f"Cannot read ROI {value}. Recognised as type {value['type']}")
+
+    return roi_list