linkml-store 0.2.9__py3-none-any.whl → 0.2.10rc1__py3-none-any.whl

linkml_store/plotting/cli.py

@@ -0,0 +1,172 @@
+"""
+Command-line interface for the plotting package.
+"""
+
+import logging
+from pathlib import Path
+from typing import Optional, Union
+
+import click
+
+from linkml_store.plotting.heatmap import heatmap_from_file, export_heatmap_data
+from linkml_store.utils.format_utils import Format
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def plot_cli():
+    """Plotting utilities for LinkML data."""
+    pass
+
+
+@plot_cli.command()
+@click.argument("input_file", required=False)
+@click.option("--x-column", "-x", required=True, help="Column to use for x-axis")
+@click.option("--y-column", "-y", required=True, help="Column to use for y-axis")
+@click.option("--value-column", "-v", help="Column containing values (if not provided, counts will be used)")
+@click.option("--title", "-t", help="Title for the heatmap")
+@click.option("--width", "-w", type=int, default=10, show_default=True, help="Width of the figure in inches")
+@click.option("--height", "-h", type=int, default=8, show_default=True, help="Height of the figure in inches")
+@click.option("--cmap", "-c", default="YlGnBu", show_default=True, help="Colormap to use")
+@click.option("--output", "-o", required=True, help="Output file path")
+@click.option("--format", "-f", help="Input file format")
+@click.option("--dpi", type=int, default=300, show_default=True, help="DPI for output image")
+@click.option("--square/--no-square", default=False, show_default=True, help="Make cells square")
+@click.option("--annotate/--no-annotate", default=True, show_default=True, help="Annotate cells with values")
+@click.option("--font-size", type=int, default=10, show_default=True, help="Font size for annotations and labels")
+@click.option("--robust/--no-robust", default=False, show_default=True, help="Use robust quantiles for colormap scaling")
+@click.option("--remove-duplicates/--no-remove-duplicates", default=True, show_default=True,
+              help="Remove duplicate x,y combinations (default) or keep all occurrences")
+@click.option("--cluster", type=click.Choice(["none", "both", "x", "y"]), default="none", show_default=True,
+              help="Cluster axes: none (default), both, x-axis only, or y-axis only")
+@click.option("--cluster-method", type=click.Choice(["complete", "average", "single", "ward"]), default="complete", show_default=True,
+              help="Linkage method for hierarchical clustering")
+@click.option("--cluster-metric", type=click.Choice(["euclidean", "correlation", "cosine", "cityblock"]), default="euclidean", show_default=True,
+              help="Distance metric for clustering")
+@click.option("--export-data", "-e", help="Export the heatmap data to this file")
+@click.option("--export-format", "-E", type=click.Choice([f.value for f in Format]), default="csv", show_default=True,
+              help="Format for exported data")
+def heatmap(
+    input_file: Optional[str],
+    x_column: str,
+    y_column: str,
+    value_column: Optional[str],
+    title: Optional[str],
+    width: int,
+    height: int,
+    cmap: str,
+    output: str,
+    format: Optional[str],
+    dpi: int,
+    square: bool,
+    annotate: bool,
+    font_size: int,
+    robust: bool,
+    remove_duplicates: bool,
+    cluster: str,
+    cluster_method: str,
+    cluster_metric: str,
+    export_data: Optional[str],
+    export_format: Union[str, Format],
+):
+    """
+    Create a heatmap from a tabular data file.
+
+    Examples:
+      # From a file
+      linkml-store plot heatmap data.csv -x species -y country -o heatmap.png
+
+      # From stdin
+      cat data.csv | linkml-store plot heatmap -x species -y country -o heatmap.png
+
+    This will create a heatmap showing the frequency counts of species by country.
+    If you want to use a specific value column instead of counts:
+
+      linkml-store plot heatmap data.csv -x species -y country -v population -o heatmap.png
+    """
+    # Handle file path - if None, use stdin
+    if input_file is None:
+        input_file = "-"  # format_utils treats "-" as stdin
+    
+    # Convert 'none' to False for clustering parameter
+    use_cluster = False if cluster == "none" else cluster
+    
+    # Create heatmap visualization
+    fig, ax = heatmap_from_file(
+        file_path=input_file,
+        x_column=x_column,
+        y_column=y_column,
+        value_column=value_column,
+        title=title,
+        figsize=(width, height),
+        cmap=cmap,
+        output_file=output,
+        format=format,
+        dpi=dpi,
+        square=square,
+        annot=annotate,
+        font_size=font_size,
+        robust=robust,
+        remove_duplicates=remove_duplicates,
+        cluster=use_cluster,
+        cluster_method=cluster_method,
+        cluster_metric=cluster_metric,
+    )
+    
+    # Export data if requested
+    if export_data:
+        # For export, reuse the data already loaded for the heatmap instead of loading again
+        # This avoids the "I/O operation on closed file" error when input_file is stdin
+        import pandas as pd
+        from matplotlib.axes import Axes
+        
+        # Extract the data directly from the plot
+        if hasattr(ax, 'get_figure') and hasattr(ax, 'get_children'):
+            # Extract the heatmap data from the plot itself
+            heatmap_data = {}
+            for child in ax.get_children():
+                if isinstance(child, plt.matplotlib.collections.QuadMesh):
+                    # Get the colormap data
+                    data_values = child.get_array()
+                    rows = ax.get_yticks()
+                    cols = ax.get_xticks()
+                    row_labels = [item.get_text() for item in ax.get_yticklabels()]
+                    col_labels = [item.get_text() for item in ax.get_xticklabels()]
+                    
+                    # Create a dataframe from the plot data
+                    heatmap_df = pd.DataFrame(
+                        index=[label for label in row_labels if label],
+                        columns=[label for label in col_labels if label]
+                    )
+                    
+                    # Fill in the values (if we can)
+                    if len(data_values) == len(row_labels) * len(col_labels):
+                        for i, row in enumerate(row_labels):
+                            for j, col in enumerate(col_labels):
+                                if row and col:  # Skip empty labels
+                                    idx = i * len(col_labels) + j
+                                    if idx < len(data_values):
+                                        heatmap_df.at[row, col] = data_values[idx]
+                    
+                    # Reset index to make the y_column a regular column
+                    result_df = heatmap_df.reset_index()
+                    result_df.rename(columns={'index': y_column}, inplace=True)
+                    
+                    # Export the data
+                    from linkml_store.utils.format_utils import write_output
+                    records = result_df.to_dict(orient='records')
+                    write_output(records, format=export_format, target=export_data)
+                    click.echo(f"Heatmap data exported to {export_data}")
+                    break
+            else:
+                # If we couldn't extract data from the plot, inform the user
+                click.echo("Warning: Could not export data from the plot")
+        else:
+            click.echo("Warning: Could not export data from the plot")
+
+    click.echo(f"Heatmap created at {output}")
+
+
+if __name__ == "__main__":
+    plot_cli()

linkml_store/plotting/heatmap.py

@@ -0,0 +1,356 @@
+"""
+Heatmap visualization module for LinkML data.
+
+This module provides functions to generate heatmaps from pandas DataFrames or tabular data files.
+"""
+
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from matplotlib.colors import LinearSegmentedColormap
+from scipy.cluster import hierarchy
+from scipy.spatial import distance
+
+from linkml_store.utils.format_utils import Format, load_objects, write_output
+
+logger = logging.getLogger(__name__)
+
+
+def create_heatmap(
+    data: pd.DataFrame,
+    x_column: str,
+    y_column: str,
+    value_column: Optional[str] = None,
+    title: Optional[str] = None,
+    figsize: Tuple[int, int] = (10, 8),
+    cmap: Union[str, LinearSegmentedColormap] = "YlGnBu",
+    annot: bool = True,
+    fmt: Optional[str] = None,  # Dynamically determined based on data
+    linewidths: float = 0.5,
+    linecolor: str = "white",
+    square: bool = False,
+    output_file: Optional[str] = None,
+    dpi: int = 300,
+    missing_value: Any = np.nan,
+    vmin: Optional[float] = None,
+    vmax: Optional[float] = None,
+    robust: bool = False,
+    remove_duplicates: bool = True,
+    font_size: int = 10,
+    cluster: Union[bool, Literal["both", "x", "y"]] = False,
+    cluster_method: str = "complete",  # linkage method: complete, average, single, etc.
+    cluster_metric: str = "euclidean",  # distance metric: euclidean, cosine, etc.
+    **kwargs,
+) -> Tuple[plt.Figure, plt.Axes]:
+    """
+    Create a heatmap from a pandas DataFrame.
+
+    Args:
+        data: Input DataFrame containing the data to plot
+        x_column: Column to use for x-axis categories
+        y_column: Column to use for y-axis categories
+        value_column: Column containing values for the heatmap. If None, frequency counts will be used.
+        title: Title for the heatmap
+        figsize: Figure size as (width, height) in inches
+        cmap: Colormap for the heatmap
+        annot: Whether to annotate cells with values
+        fmt: String formatting code for annotations (auto-detected if None)
+        linewidths: Width of lines between cells
+        linecolor: Color of lines between cells
+        square: Whether to make cells square
+        output_file: File path to save the figure (optional)
+        dpi: Resolution for saved figure
+        missing_value: Value to use for missing data (defaults to NaN)
+        vmin: Minimum value for colormap scaling
+        vmax: Maximum value for colormap scaling
+        robust: If True, compute colormap limits using robust quantiles instead of min/max
+        remove_duplicates: If True, removes duplicate rows before creating the heatmap
+        font_size: Font size for annotations
+        cluster: Whether and which axes to cluster:
+                - False: No clustering (default)
+                - True or "both": Cluster both x and y axes
+                - "x": Cluster only x-axis
+                - "y": Cluster only y-axis
+        cluster_method: Linkage method for hierarchical clustering
+                      (e.g., "single", "complete", "average", "ward")
+        cluster_metric: Distance metric for clustering (e.g., "euclidean", "correlation", "cosine")
+        **kwargs: Additional keyword arguments to pass to seaborn's heatmap function
+
+    Returns:
+        Tuple containing the figure and axes objects
+    """
+    # Validate input
+    if x_column not in data.columns:
+        raise ValueError(f"x_column '{x_column}' not found in DataFrame columns: {list(data.columns)}")
+    if y_column not in data.columns:
+        raise ValueError(f"y_column '{y_column}' not found in DataFrame columns: {list(data.columns)}")
+    if value_column and value_column not in data.columns:
+        raise ValueError(f"value_column '{value_column}' not found in DataFrame columns: {list(data.columns)}")
+
+    # Remove duplicates by default (assume they're accidents unless user overrides)
+    if remove_duplicates:
+        data = data.drop_duplicates()
+    
+    # Prepare the data
+    if value_column:
+        # Use the provided value column
+        pivot_data = data.pivot_table(
+            index=y_column, 
+            columns=x_column, 
+            values=value_column, 
+            aggfunc='mean',
+            fill_value=missing_value
+        )
+    else:
+        # Use frequency counts
+        cross_tab = pd.crosstab(data[y_column], data[x_column])
+        pivot_data = cross_tab
+    
+    # Auto-detect format string if not provided
+    if fmt is None:
+        # Check if the pivot table contains integers only
+        if pivot_data.dtypes.apply(lambda x: pd.api.types.is_integer_dtype(x)).all():
+            fmt = 'd'  # Integer format
+        else:
+            fmt = '.1f'  # One decimal place for floats
+    
+    # Make sure all cells have a reasonable minimum size
+    min_height = max(4, 80 / len(pivot_data.index) if len(pivot_data.index) > 0 else 10)
+    min_width = max(4, 80 / len(pivot_data.columns) if len(pivot_data.columns) > 0 else 10)
+    
+    # Adjust figure size based on the number of rows and columns 
+    adjusted_height = max(figsize[1], min_height * len(pivot_data.index) / 10)
+    adjusted_width = max(figsize[0], min_width * len(pivot_data.columns) / 10)
+    adjusted_figsize = (adjusted_width, adjusted_height)
+    
+    # Create figure and axes
+    fig, ax = plt.subplots(figsize=adjusted_figsize)
+    
+    # Apply clustering if requested
+    row_linkage = None
+    col_linkage = None
+    
+    if cluster:
+        cluster_axes = cluster
+        if cluster_axes is True:
+            cluster_axes = "both"
+            
+        # Fill NAs for clustering
+        pivot_data_for_clustering = pivot_data.fillna(0)
+        
+        # Cluster rows (y-axis)
+        if cluster_axes in ["both", "y"]:
+            try:
+                # Calculate distance matrix and linkage for rows
+                row_distances = distance.pdist(pivot_data_for_clustering.values, metric=cluster_metric)
+                row_linkage = hierarchy.linkage(row_distances, method=cluster_method)
+                
+                # Reorder rows based on clustering
+                row_dendrogram = hierarchy.dendrogram(row_linkage, no_plot=True)
+                row_order = row_dendrogram['leaves']
+                pivot_data = pivot_data.iloc[row_order]
+                
+                logger.info(f"Applied clustering to rows using {cluster_method} linkage and {cluster_metric} metric")
+            except Exception as e:
+                logger.warning(f"Failed to cluster rows: {e}")
+        
+        # Cluster columns (x-axis)
+        if cluster_axes in ["both", "x"]:
+            try:
+                # Calculate distance matrix and linkage for columns
+                col_distances = distance.pdist(pivot_data_for_clustering.values.T, metric=cluster_metric)
+                col_linkage = hierarchy.linkage(col_distances, method=cluster_method)
+                
+                # Reorder columns based on clustering
+                col_dendrogram = hierarchy.dendrogram(col_linkage, no_plot=True)
+                col_order = col_dendrogram['leaves']
+                pivot_data = pivot_data.iloc[:, col_order]
+                
+                logger.info(f"Applied clustering to columns using {cluster_method} linkage and {cluster_metric} metric")
+            except Exception as e:
+                logger.warning(f"Failed to cluster columns: {e}")
+
+    # Create the heatmap
+    sns.heatmap(
+        pivot_data,
+        cmap=cmap,
+        annot=annot,
+        fmt=fmt,
+        linewidths=linewidths,
+        linecolor=linecolor,
+        square=square,
+        vmin=vmin,
+        vmax=vmax,
+        robust=robust,
+        ax=ax,
+        annot_kws={'fontsize': font_size},
+        **kwargs
+    )
+    
+    # Set title if provided
+    if title:
+        ax.set_title(title, fontsize=font_size + 4)
+    
+    # Improve display of tick labels
+    plt.xticks(rotation=45, ha="right", fontsize=font_size)
+    plt.yticks(rotation=0, fontsize=font_size)
+    
+    # Add grid lines to make the table more readable
+    ax.grid(False)
+    
+    # Improve contrast for better readability
+    for _, spine in ax.spines.items():
+        spine.set_visible(True)
+        spine.set_color('black')
+        spine.set_linewidth(1)
+    
+    # Adjust layout
+    plt.tight_layout()
+    
+    # Save the figure if output file is specified
+    if output_file:
+        output_path = Path(output_file)
+        output_dir = output_path.parent
+        if not output_dir.exists():
+            output_dir.mkdir(parents=True, exist_ok=True)
+        plt.savefig(output_file, dpi=dpi, bbox_inches="tight")
+        logger.info(f"Heatmap saved to {output_file}")
+    
+    return fig, ax
+
+
+def heatmap_from_file(
+    file_path: str,
+    x_column: str,
+    y_column: str,
+    value_column: Optional[str] = None,
+    format: Optional[Union[Format, str]] = None,
+    compression: Optional[str] = None,
+    output_file: Optional[str] = None,
+    remove_duplicates: bool = True,
+    **kwargs,
+) -> Tuple[plt.Figure, plt.Axes]:
+    """
+    Create a heatmap from a file (CSV, TSV, etc.).
+
+    Args:
+        file_path: Path to the input file or "-" for stdin
+        x_column: Column to use for x-axis categories
+        y_column: Column to use for y-axis categories
+        value_column: Column containing values for the heatmap. If None, frequency counts will be used.
+        format: Format of the input file (auto-detected if None)
+        compression: Compression format ('gz' or 'tgz')
+        output_file: File path to save the figure (optional)
+        remove_duplicates: If True, removes duplicate rows before creating the heatmap
+        **kwargs: Additional arguments to pass to create_heatmap
+
+    Returns:
+        Tuple containing the figure and axes objects
+    """
+    # Handle stdin input safely
+    import sys
+    import io
+    import pandas as pd
+    import click
+    
+    # Load the data
+    if file_path == "-":
+        # Read directly from stdin since format_utils will use sys.stdin which may already be consumed
+        if not format or str(format).lower() in ['csv', 'tsv']:
+            # Default to CSV if no format specified
+            delimiter = ',' if not format or str(format).lower() == 'csv' else '\t'
+            df = pd.read_csv(sys.stdin, delimiter=delimiter)
+        else:
+            # Try to use format_utils but with a backup plan
+            try:
+                objs = load_objects(file_path, format=format, compression=compression)
+                df = pd.DataFrame(objs)
+            except ValueError as e:
+                if "I/O operation on closed file" in str(e):
+                    logger.warning("Could not read from stdin. It may have been consumed already.")
+                    raise click.UsageError("Error reading from stdin. Please provide a file path or ensure stdin has data.")
+                else:
+                    raise
+    else:
+        # For regular files, use format_utils as normal
+        if (not format or format in ["csv", "tsv"]) and not compression:
+            df = pd.read_csv(file_path)
+        else:
+            objs = load_objects(file_path, format=format, compression=compression)
+            df = pd.DataFrame(objs)
+
+    # Create the heatmap
+    return create_heatmap(
+        data=df,
+        x_column=x_column,
+        y_column=y_column,
+        value_column=value_column,
+        output_file=output_file,
+        remove_duplicates=remove_duplicates,
+        **kwargs
+    )
+
+
+def export_heatmap_data(
+    data: pd.DataFrame,
+    x_column: str,
+    y_column: str,
+    value_column: Optional[str] = None,
+    output_file: Optional[str] = None,
+    format: Union[Format, str] = Format.CSV,
+    missing_value: Any = np.nan,
+    remove_duplicates: bool = True,
+) -> pd.DataFrame:
+    """
+    Export heatmap data to a file or return it as a DataFrame.
+
+    Args:
+        data: Input DataFrame containing the data
+        x_column: Column to use for x-axis categories
+        y_column: Column to use for y-axis categories
+        value_column: Column containing values for the heatmap. If None, frequency counts will be used.
+        output_file: File path to save the data (optional)
+        format: Output format for the file
+        missing_value: Value to use for missing data
+        remove_duplicates: If True, removes duplicate rows before creating the pivot table
+
+    Returns:
+        DataFrame containing the pivot table data
+    """
+    # Remove duplicates by default (assume they're accidents unless user overrides)
+    if remove_duplicates:
+        # Keep the first occurrence of each x_column, y_column combination
+        data = data.drop_duplicates(subset=[x_column, y_column])
+
+    # Prepare the data
+    if value_column:
+        # Use the provided value column
+        pivot_data = data.pivot_table(
+            index=y_column, 
+            columns=x_column, 
+            values=value_column, 
+            aggfunc='mean',
+            fill_value=missing_value
+        )
+    else:
+        # Use frequency counts
+        cross_tab = pd.crosstab(data[y_column], data[x_column])
+        pivot_data = cross_tab
+    
+    # Reset index to make the y_column a regular column
+    result_df = pivot_data.reset_index()
+    
+    # Write to file if output_file is provided
+    if output_file:
+        # Convert to records format for writing
+        records = result_df.to_dict(orient='records')
+        write_output(records, format=format, target=output_file)
+        logger.info(f"Heatmap data saved to {output_file}")
+    
+    return result_df

linkml_store/utils/dat_parser.py

@@ -1,4 +1,4 @@
-from typing import Tuple, Optional, Dict, Any, List
+from typing import Any, Dict, List, Optional, Tuple
 
 ENTRY = Dict[str, Any]
 

linkml_store/utils/enrichment_analyzer.py

@@ -1,9 +1,12 @@
-import pandas as pd
-import numpy as np
-from linkml_store.api import Collection
-from scipy import stats
+from collections import Counter
 from typing import Dict, List
+
+import numpy as np
+import pandas as pd
 from pydantic import BaseModel
+from scipy import stats
+
+from linkml_store.api import Collection
 
 
 class EnrichedCategory(BaseModel):
@@ -17,9 +20,6 @@ class EnrichedCategory(BaseModel):
     adjusted_p_value: float
 
 
-from collections import Counter, defaultdict
-
-
 class EnrichmentAnalyzer:
     def __init__(self, df: pd.DataFrame, sample_key: str, classification_key: str):
         """

linkml_store/utils/llm_utils.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Callable, List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, List, Optional
 
 if TYPE_CHECKING:
     import tiktoken

linkml_store/utils/object_utils.py

@@ -83,15 +83,21 @@ def object_path_get(obj: Union[BaseModel, Dict[str, Any]], path: str, default_va
     'NA'
     """
     if isinstance(obj, BaseModel):
-        obj = obj.dict()
+        obj = obj.model_dump()
     parts = path.split(".")
     for part in parts:
         if "[" in part:
             key, index = part[:-1].split("[")
             index = int(index)
-            obj = obj[key][index]
+            if key in obj and obj[key] is not None:
+                obj = obj[key][index]
+            else:
+                return default_value
         else:
-            obj = obj.get(part, default_value)
+            if isinstance(obj, list):
+                obj = [v1.get(part, default_value) for v1 in obj]
+            else:
+                obj = obj.get(part, default_value)
     return obj
 
 

{linkml_store-0.2.9.dist-info → linkml_store-0.2.10rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: linkml-store
-Version: 0.2.9
+Version: 0.2.10rc1
 Summary: linkml-store
 License: MIT
 Author: Author 1