phenome 1.4.1__tar.gz

phenome-1.4.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aitor González-Marfil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

phenome-1.4.1/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: phenome
+Version: 1.4.1
+Summary: PhenoMe: dataset-agnostic phenotyping pipeline using deep learning embeddings
+Author: Aitor González-Marfil
+License: MIT
+Project-URL: Homepage, https://github.com/AAitorG/PhenoMe
+Project-URL: Repository, https://github.com/AAitorG/PhenoMe
+Project-URL: Documentation, https://AAitorG.github.io/PhenoMe/
+Project-URL: Bug Tracker, https://github.com/AAitorG/PhenoMe/issues
+Project-URL: Changelog, https://github.com/AAitorG/PhenoMe/blob/main/CHANGELOG.md
+Keywords: phenotyping,bioimaging,computer vision,deep learning,embeddings,microscopy,cell biology,image analysis,pytorch,drug discovery
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torchvision>=0.15.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: plotly
+Requires-Dist: kaleido
+Requires-Dist: scikit-learn
+Requires-Dist: joblib
+Requires-Dist: tqdm
+Requires-Dist: opencv-python
+Requires-Dist: tifffile
+Requires-Dist: h5py
+Requires-Dist: scipy
+Requires-Dist: scikit-image>=0.26.0
+Requires-Dist: ipywidgets
+Requires-Dist: anywidget
+Requires-Dist: pillow
+Requires-Dist: umap-learn==0.5.12
+Requires-Dist: nibabel<6,>=5.2.0
+Requires-Dist: dcor==0.7
+Requires-Dist: ipykernel>=6.29
+Requires-Dist: jupyterlab>=4.0
+Requires-Dist: jupyterlab_widgets>=3.0
+Requires-Dist: nbformat>=5.9
+Provides-Extra: full
+Requires-Dist: pykeops==2.3; sys_platform != "win32" and extra == "full"
+Requires-Dist: torchdr<0.6,>=0.1; extra == "full"
+Provides-Extra: mcp
+Requires-Dist: mcp>=2.0; extra == "mcp"
+Provides-Extra: dev
+Requires-Dist: codespell>=2.4; extra == "dev"
+Requires-Dist: interrogate>=1.7.0; extra == "dev"
+Requires-Dist: mypy>=1.19.1; extra == "dev"
+Requires-Dist: pandas-stubs; extra == "dev"
+Requires-Dist: pre-commit>=3.7; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.15.4; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Requires-Dist: types-setuptools; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+  <img src="docs/assets/logo.png" alt="PhenoMe logo" width="360"/>
+
+  <p>A modular, <b>dataset-agnostic</b> and <b>model-agnostic</b> framework for phenotyping analysis, combining deep learning embeddings and image properties.</p>
+</div>
+
+---
+
+### 🗺️ Navigation
+
+**[✨ Features](#-features)** | **[🚀 Quick Start](#-quick-start)** | **[📦 Installation](#-installation)** | **[📖 Documentation](https://AAitorG.github.io/PhenoMe/)** | **[📜 Citation](#-citation)**
+
+---
+
+## ✨ Features
+
+- 🧠 **Model Agnostic**: Extract embeddings using DINOv2 or any custom vision model (PyTorch, TensorFlow, Keras, etc.) via the modular `ModelWrapper` interface.
+- 📂 **Dataset Agnostic**: Works with any image dataset structure with customizable metadata extraction.
+- 🛠️ **Analysis Toolkit**: Distance quantification, anomaly detection, property extraction, and correlation analysis.
+- 📊 **Interactive Visualizations**: High-performance Plotly-based PCA, t-SNE, and UMAP plots.
+- 📑 **Automated Reporting**: Generate comprehensive standalone HTML reports.
+
+---
+
+## 🚀 Quick Start
+
+Try the no-code experience with the **[Interactive Quickstart Notebook](Notebooks/tutorials/01_interactive_quickstart.ipynb)** or launch instantly in Colab:
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/AAitorG/PhenoMe/blob/main/Notebooks/tutorials/01_interactive_quickstart.ipynb)
+
+---
+
+## 📦 Installation
+
+```bash
+pip install phenome
+```
+
+PyTorch is included. An NVIDIA GPU is used when CUDA is available; the same install runs on CPU.
+
+<details>
+<summary><b>Conda or from source</b></summary>
+
+Clone the repository, then create one environment for your hardware. These files pin the scientific stack and install this checkout.
+
+```bash
+git clone https://github.com/AAitorG/PhenoMe.git
+cd PhenoMe
+```
+
+**GPU**
+```bash
+conda env create -f envs/environment-gpu.yml
+conda activate phenome-gpu
+```
+
+**CPU**
+```bash
+conda env create -f envs/environment-cpu.yml
+conda activate phenome-cpu
+```
+</details>
+
+> **💡 Full instructions, verification, and troubleshooting:**
+> See the [Getting started](https://AAitorG.github.io/PhenoMe/getting-started/) guide for install details, verification commands, and first-analysis walkthroughs.
+
+---
+
+## 📖 Documentation
+
+**Explore the [Full Documentation](https://AAitorG.github.io/PhenoMe/)** for detailed guides, API references, and tutorials.
+
+| Step | Resource |
+| ---- | -------- |
+| 1️⃣ **Install** | [Getting started](https://AAitorG.github.io/PhenoMe/getting-started/) |
+| 2️⃣ **Set up your data** | [Data setup](https://AAitorG.github.io/PhenoMe/guides/data-setup/) · [Experiment details](https://AAitorG.github.io/PhenoMe/guides/experiment-details/) |
+| 3️⃣ **Tutorials** | [Notebooks/tutorials/](Notebooks/tutorials/) |
+| 4️⃣ **Examples** | [Notebooks/examples/](Notebooks/examples/) |
+
+**Learn More:** [Core concepts](https://AAitorG.github.io/PhenoMe/concepts/) · [Workflows](https://AAitorG.github.io/PhenoMe/workflows/) · [FAQ](https://AAitorG.github.io/PhenoMe/faq/) · [Glossary](https://AAitorG.github.io/PhenoMe/glossary/)
+
+---
+
+## 📜 Citation
+
+If you use PhenoMe in your research, please cite:
+
+```bibtex
+@software{phenome,
+  author = {Aitor González-Marfil},
+  title = {PhenoMe: Interactive AI framework for image representation analysis},
+  year = {2026},
+  url = {https://github.com/AAitorG/PhenoMe}
+}
+```

phenome-1.4.1/README.md

@@ -0,0 +1,95 @@
+<div align="center">
+  <img src="docs/assets/logo.png" alt="PhenoMe logo" width="360"/>
+
+  <p>A modular, <b>dataset-agnostic</b> and <b>model-agnostic</b> framework for phenotyping analysis, combining deep learning embeddings and image properties.</p>
+</div>
+
+---
+
+### 🗺️ Navigation
+
+**[✨ Features](#-features)** | **[🚀 Quick Start](#-quick-start)** | **[📦 Installation](#-installation)** | **[📖 Documentation](https://AAitorG.github.io/PhenoMe/)** | **[📜 Citation](#-citation)**
+
+---
+
+## ✨ Features
+
+- 🧠 **Model Agnostic**: Extract embeddings using DINOv2 or any custom vision model (PyTorch, TensorFlow, Keras, etc.) via the modular `ModelWrapper` interface.
+- 📂 **Dataset Agnostic**: Works with any image dataset structure with customizable metadata extraction.
+- 🛠️ **Analysis Toolkit**: Distance quantification, anomaly detection, property extraction, and correlation analysis.
+- 📊 **Interactive Visualizations**: High-performance Plotly-based PCA, t-SNE, and UMAP plots.
+- 📑 **Automated Reporting**: Generate comprehensive standalone HTML reports.
+
+---
+
+## 🚀 Quick Start
+
+Try the no-code experience with the **[Interactive Quickstart Notebook](Notebooks/tutorials/01_interactive_quickstart.ipynb)** or launch instantly in Colab:
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/AAitorG/PhenoMe/blob/main/Notebooks/tutorials/01_interactive_quickstart.ipynb)
+
+---
+
+## 📦 Installation
+
+```bash
+pip install phenome
+```
+
+PyTorch is included. An NVIDIA GPU is used when CUDA is available; the same install runs on CPU.
+
+<details>
+<summary><b>Conda or from source</b></summary>
+
+Clone the repository, then create one environment for your hardware. These files pin the scientific stack and install this checkout.
+
+```bash
+git clone https://github.com/AAitorG/PhenoMe.git
+cd PhenoMe
+```
+
+**GPU**
+```bash
+conda env create -f envs/environment-gpu.yml
+conda activate phenome-gpu
+```
+
+**CPU**
+```bash
+conda env create -f envs/environment-cpu.yml
+conda activate phenome-cpu
+```
+</details>
+
+> **💡 Full instructions, verification, and troubleshooting:**
+> See the [Getting started](https://AAitorG.github.io/PhenoMe/getting-started/) guide for install details, verification commands, and first-analysis walkthroughs.
+
+---
+
+## 📖 Documentation
+
+**Explore the [Full Documentation](https://AAitorG.github.io/PhenoMe/)** for detailed guides, API references, and tutorials.
+
+| Step | Resource |
+| ---- | -------- |
+| 1️⃣ **Install** | [Getting started](https://AAitorG.github.io/PhenoMe/getting-started/) |
+| 2️⃣ **Set up your data** | [Data setup](https://AAitorG.github.io/PhenoMe/guides/data-setup/) · [Experiment details](https://AAitorG.github.io/PhenoMe/guides/experiment-details/) |
+| 3️⃣ **Tutorials** | [Notebooks/tutorials/](Notebooks/tutorials/) |
+| 4️⃣ **Examples** | [Notebooks/examples/](Notebooks/examples/) |
+
+**Learn More:** [Core concepts](https://AAitorG.github.io/PhenoMe/concepts/) · [Workflows](https://AAitorG.github.io/PhenoMe/workflows/) · [FAQ](https://AAitorG.github.io/PhenoMe/faq/) · [Glossary](https://AAitorG.github.io/PhenoMe/glossary/)
+
+---
+
+## 📜 Citation
+
+If you use PhenoMe in your research, please cite:
+
+```bibtex
+@software{phenome,
+  author = {Aitor González-Marfil},
+  title = {PhenoMe: Interactive AI framework for image representation analysis},
+  year = {2026},
+  url = {https://github.com/AAitorG/PhenoMe}
+}
+```

phenome-1.4.1/phenome/__init__.py

@@ -0,0 +1,180 @@
+"""
+@section Core Pipeline
+
+PhenoMe Package
+
+A modular, **dataset-agnostic** and **model-agnostic** pipeline for phenotyping
+analysis using deep learning embeddings.
+
+**Overview:**
+PhenoMe orchestrates the full phenotyping workflow: discover images, extract embeddings
+with custom or pretrained models, compute cell/object properties, perform statistical
+analysis, and generate interactive visualizations and reports.
+
+**Public API:**
+
+Core orchestration:
+- `PhenoMe`: Main pipeline class; find images, process embeddings, compute properties, analyze.
+- `PhenoMeResults`: Container for embeddings, properties, metadata, and analysis results.
+
+Metadata helpers:
+- `DefaultMetadata`: Simple key-value metadata.
+- `PathTemplateMetadata`: Extract metadata from file paths using templates.
+- `DataFrameMetadata`: Use a DataFrame as metadata source.
+- `default_metadata_from_path`, `get_metadata_from_path`, `make_dataframe_metadata_fn`:
+  Metadata factory functions.
+
+Model loading:
+- `load_dinov2_model`: Load pretrained DINOv2 model.
+
+Property factories (create custom cell/object properties):
+- `create_regionprops_function`, `create_intensity_function`,
+  `create_masked_intensity_function`, `create_texture_function`,
+  `create_concentric_ring_function`, `create_blur_effect_function`,
+  `create_entropy_function`: Built-in property creators.
+- `get_preset_property_functions`: List all available preset properties.
+
+**Data flow:**
+
+```
+find_files()
+    ↓ returns DataFrame of image paths
+set_file_df() or directly via DataFrame
+    ↓ store file locations
+process_images(model)
+    ↓ extract embeddings, populate results.embeddings
+compute_properties(property_functions)
+    ↓ compute morphological/biological features
+compute_clustering() / detect_outliers() / ...
+    ↓ statistical analysis
+plot_pca() / plot_tsne() / plot_umap() / ...
+    ↓ visualization
+generate_report()
+    ↓ HTML report
+```
+
+**Model compatibility:**
+- **DINOv2:** Use `load_dinov2_model()` or wrap with `DinoV2ModelWrapper`.
+- **Custom:** Subclass `ModelWrapper`, implement `_get_embeddings(images) -> (B, D)`.
+
+**For advanced usage, import from submodules:**
+- `phenome.core`: Math utilities (DR, correlation, validation, export).
+- `phenome.io`: File I/O (`read_image`, `FileDiscovery`, `CheckpointManager`).
+- `phenome.mixins`: Composition classes (dataset, properties, analysis, visualization).
+- `phenome.plugins`: Property registry and custom property registration.
+- `phenome.report`: HTML report generation.
+- `phenome.utils`: Device management, transforms, metadata and property factories.
+
+**Logging:**
+
+Progress messages are visible at INFO level by default:
+
+```python
+import logging
+logging.getLogger("phenome").setLevel(logging.WARNING)  # Suppress
+```
+
+**Example:**
+
+Basic phenotyping workflow:
+
+```python
+from phenome import PhenoMe, load_dinov2_model
+
+# Initialize pipeline
+pm = PhenoMe(device="cuda", seed=42)
+
+# Find images
+pm.find_files("path/to/images/")
+
+# Extract embeddings
+model = load_dinov2_model(model_name="dinov2_vitb14")
+pm.process_images(model, batch_size=32)
+
+# Compute properties
+pm.compute_properties(property_preset="basic")
+
+# Analyze
+pm.compute_clustering(method="kmeans", n_clusters=5)
+pm.compute_pca()
+
+# Visualize
+pm.plot_pca(color_by="clustering")
+```
+
+**See Also:**
+For architecture, design patterns, and extensibility, see the [Architecture guide](https://AAitorG.github.io/PhenoMe/guides/architecture/).
+"""
+
+# Initialise notebook-safe logging on first import
+from importlib.metadata import PackageNotFoundError, version
+
+from ._logging import get_logger as _get_logger
+from .core import PhenoMeResults
+from .metadata import (
+    DataFrameMetadata,
+    DefaultMetadata,
+    MetadataBase,
+    PathTemplateMetadata,
+)
+from .pipeline import PhenoMe
+from .plotly_display import register_plotly_display_defaults
+
+# Metadata functions and classes
+from .utils.metadata import (
+    default_metadata_from_path,
+    get_metadata_from_path,
+    make_dataframe_metadata_fn,
+)
+
+# Core workflow helpers
+from .utils.model_wrapper import load_dinov2_model
+
+# Property factories
+from .utils.property_factories import (
+    create_blur_effect_function,
+    create_concentric_ring_function,
+    create_entropy_function,
+    create_intensity_function,
+    create_masked_intensity_function,
+    create_regionprops_function,
+    create_texture_function,
+    get_preset_property_functions,
+)
+
+try:
+    __version__ = version("phenome")
+except PackageNotFoundError:
+    __version__ = "1.4.1"
+
+__all__ = [
+    "DataFrameMetadata",
+    "DefaultMetadata",
+    "MetadataBase",
+    "PathTemplateMetadata",
+    "PhenoMe",
+    "PhenoMeResults",
+    "__version__",
+    # Property factories
+    "create_blur_effect_function",
+    "create_concentric_ring_function",
+    "create_entropy_function",
+    "create_intensity_function",
+    "create_masked_intensity_function",
+    "create_regionprops_function",
+    "create_texture_function",
+    # Metadata functions
+    "default_metadata_from_path",
+    "get_metadata_from_path",
+    # Property factories
+    "get_preset_property_functions",
+    # Default models
+    "load_dinov2_model",
+    "make_dataframe_metadata_fn",
+]
+
+_get_logger(__name__)
+__author__ = "Aitor González-Marfil"
+__author_github__ = "AAitorG"
+
+register_plotly_display_defaults()

phenome-1.4.1/phenome/_logging.py

@@ -0,0 +1,99 @@
+"""
+Notebook-safe logging configuration for phenome.
+
+Problem
+-------
+The standard ``logging.getLogger(__name__)`` pattern silently drops INFO
+messages in Jupyter notebooks because Python's root logger defaults to
+WARNING level and has no handler attached.  If the user manually adds a
+handler, duplicate output appears on every cell re-run.
+
+Solution
+--------
+We configure a single package-level logger (``phenome``) with:
+
+* A ``StreamHandler`` writing to ``sys.stderr`` (rendered by Jupyter as
+  plain text below the cell).
+* INFO as default level, so progress messages are always visible.
+* A guard that prevents adding duplicate handlers on module reload
+  (``%autoreload`` / repeated imports).
+
+All sub-modules should call::
+
+    from ._logging import get_logger
+    logger = get_logger(__name__)
+
+instead of ``logging.getLogger(__name__)``.
+
+Users who want to silence the output can do::
+
+    import logging
+    logging.getLogger("phenome").setLevel(logging.WARNING)
+"""
+
+import logging
+import sys
+
+# Package-level logger name
+_PKG_LOGGER_NAME = "phenome"
+
+# Sentinel attribute on the package logger so we configure at most once.
+_CONFIGURED_ATTR = "_phenome_configured"
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Return a logger configured for notebook-safe output.
+
+    Typical usage at the top of each module::
+
+        from ._logging import get_logger
+        logger = get_logger(__name__)
+
+    Parameters
+    ----------
+    name : str
+        Usually ``__name__`` of the calling module.
+    """
+    _ensure_configured()
+    return logging.getLogger(name)
+
+
+def _ensure_configured() -> None:
+    """Attach a StreamHandler to the package logger if not done already."""
+    pkg_logger = logging.getLogger(_PKG_LOGGER_NAME)
+
+    if getattr(pkg_logger, _CONFIGURED_ATTR, False):
+        return
+
+    # Library best-practice: add NullHandler so that if the user never
+    # configures logging at all, nothing breaks.
+    pkg_logger.addHandler(logging.NullHandler())
+
+    # Only add our StreamHandler if the package logger (or its parents)
+    # have no *effective* handlers yet.  This avoids fighting with a
+    # user who already configured logging before importing us.
+    if not _has_effective_handler(pkg_logger):
+        handler = logging.StreamHandler(sys.stderr)
+        handler.setFormatter(logging.Formatter("%(message)s"))
+        pkg_logger.addHandler(handler)
+
+    # Set INFO as the default level for the package tree.
+    # Only override if the logger is still at NOTSET (i.e. the user hasn't
+    # explicitly set a level).
+    if pkg_logger.level == logging.NOTSET:
+        pkg_logger.setLevel(logging.INFO)
+
+    setattr(pkg_logger, _CONFIGURED_ATTR, True)
+
+
+def _has_effective_handler(logger: logging.Logger) -> bool:
+    """Check if *logger* or any ancestor already has a non-NullHandler."""
+    current: logging.Logger | None = logger
+    while current:
+        for h in current.handlers:
+            if not isinstance(h, logging.NullHandler):
+                return True
+        if not current.propagate:
+            break
+        current = current.parent
+    return False

phenome-1.4.1/phenome/core/__init__.py

@@ -0,0 +1,107 @@
+"""
+@section Core Pipeline
+
+Core utilities for math, validation, export, and results management.
+
+This package provides the mathematical algorithms and data structures that underpin
+the phenotyping pipeline. Key components:
+
+**Results container:**
+- `PhenoMeResults`: Typed container for embeddings, properties, metadata, and analysis results.
+
+**Mathematical functions:**
+- `run_dimensionality_reduction`: PCA, t-SNE, UMAP.
+- `compute_pearson_correlation`, `compute_spearman_correlation`: Feature correlations.
+- `compute_distance_correlation`: Distance correlation between features.
+- `compute_mutual_info`: Mutual information between features.
+- `compute_entropy`: Entropy of features.
+- `build_combined_features`: Combine multiple features into single representation.
+
+**Validation and export:**
+- `validate_results`: Check results integrity (embeddings, properties, shapes).
+- `build_export_dataframe`: Format results for export to CSV/Excel.
+- `prepare_embedding_dataframe`: Prepare embeddings with metadata for analysis.
+
+**Metadata handling:**
+- `build_metadata_columns`: Extract and format metadata columns.
+- `filter_indices`: Select rows by metadata criteria.
+- `get_metadata_value`: Retrieve metadata value for a row.
+- `get_all_metadata_keys`: List all available metadata keys.
+- `metadata_to_stable_key`: Convert metadata to file-safe string.
+
+**Protocols:**
+- `PhenoMeProtocol`: Protocol (duck-type interface) for objects implementing the phenotyping API.
+
+**See Also:**
+For top-level analysis pipeline, see `phenome.PhenoMe`.
+"""
+
+from .dataframe_contract import (
+    IMAGE_INDEX,
+    IMAGE_NAME,
+    IMAGE_PATH,
+    TIER_A_EXCLUDE_FROM_PROPERTIES,
+    append_property_columns,
+    is_per_image_df,
+    per_image_dataframe,
+    reorder_tier_a_columns,
+)
+from .math import (
+    build_combined_features,
+    clean_correlation_inputs,
+    compute_distance_correlation,
+    compute_entropy,
+    compute_lasso_interpretability,
+    compute_mutual_info,
+    compute_pearson_correlation,
+    compute_rf_interpretability,
+    compute_spearman_correlation,
+    run_dimensionality_reduction,
+    run_dimensionality_reduction_matrix,
+)
+from .pipeline_results import PhenoMeResults
+from .property_utils import metadata_to_stable_key, optimize_property_types
+from .protocols import PhenoMeProtocol
+from .results_export import build_export_dataframe, prepare_embedding_dataframe
+from .results_metadata import (
+    build_metadata_columns,
+    filter_indices,
+    get_all_metadata_keys,
+    get_metadata_value,
+    get_metadata_value_from_dict,
+)
+from .results_validation import validate_results
+
+__all__ = [
+    "IMAGE_INDEX",
+    "IMAGE_NAME",
+    "IMAGE_PATH",
+    "TIER_A_EXCLUDE_FROM_PROPERTIES",
+    "PhenoMeProtocol",
+    "PhenoMeResults",
+    "append_property_columns",
+    "build_combined_features",
+    "build_export_dataframe",
+    "build_metadata_columns",
+    "clean_correlation_inputs",
+    "compute_distance_correlation",
+    "compute_entropy",
+    "compute_lasso_interpretability",
+    "compute_mutual_info",
+    "compute_pearson_correlation",
+    "compute_rf_interpretability",
+    "compute_spearman_correlation",
+    "filter_indices",
+    "get_all_metadata_keys",
+    "get_metadata_value",
+    "get_metadata_value_from_dict",
+    "is_per_image_df",
+    "metadata_to_stable_key",
+    "optimize_property_types",
+    "per_image_dataframe",
+    "prepare_embedding_dataframe",
+    "reorder_tier_a_columns",
+    "run_dimensionality_reduction",
+    "run_dimensionality_reduction_matrix",
+    "validate_results",
+]