scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/io/_save_modules/_tex.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-01 21:30:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/io/_save_modules/_tex.py
+# ----------------------------------------
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+Save objects as LaTeX/TeX format.
+
+Supports multiple input types:
+- pandas DataFrames → LaTeX tables via df.to_latex()
+- dicts/lists → LaTeX tables via convert_results()
+- str → Direct write (pre-formatted TeX)
+- matplotlib figures → TikZ/PGFPlots (future enhancement)
+"""
+
+from typing import Union, Optional, Any
+import warnings
+
+
+def save_tex(
+    obj: Any,
+    spath: str,
+    caption: Optional[str] = None,
+    label: Optional[str] = None,
+    document: bool = False,
+    longtable: bool = False,
+    escape: bool = True,
+    **kwargs
+) -> None:
+    """
+    Save object as LaTeX/TeX format.
+
+    Parameters
+    ----------
+    obj : Any
+        Object to save. Supported types:
+        - pandas.DataFrame: Converted to LaTeX table
+        - dict/list[dict]: Converted via convert_results() if available
+        - str: Written directly as pre-formatted TeX
+        - Other: Attempted conversion to string
+    spath : str
+        Path where the .tex file will be saved.
+    caption : str, optional
+        Table caption (wrapped in \\caption{})
+    label : str, optional
+        Table label for referencing (wrapped in \\label{})
+    document : bool, default False
+        If True, wrap content in full LaTeX document structure
+    longtable : bool, default False
+        Use longtable environment for multi-page tables (DataFrames only)
+    escape : bool, default True
+        Escape special LaTeX characters (DataFrames only)
+    **kwargs
+        Additional arguments passed to df.to_latex() or convert_results()
+
+    Returns
+    -------
+    None
+
+    Examples
+    --------
+    >>> import pandas as pd
+    >>> import scitex as stx
+    >>>
+    >>> # Save DataFrame as LaTeX table
+    >>> df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
+    >>> stx.io.save(df, 'table.tex')
+    >>>
+    >>> # With caption and label
+    >>> stx.io.save(df, 'table.tex', caption='My Results', label='tab:results')
+    >>>
+    >>> # Save raw LaTeX string
+    >>> latex = r'\\begin{equation} E = mc^2 \\end{equation}'
+    >>> stx.io.save(latex, 'equation.tex')
+    >>>
+    >>> # Full document
+    >>> stx.io.save(df, 'doc.tex', document=True)
+
+    Notes
+    -----
+    - For DataFrames, uses pandas.DataFrame.to_latex()
+    - For dicts/lists, attempts to use scitex.stats.utils.convert_results()
+    - For strings, writes content directly
+    - The document=True option creates a complete compilable LaTeX document
+    """
+    import pandas as pd
+
+    # Determine content based on object type
+    tex_content = None
+
+    if isinstance(obj, str):
+        # Direct string writing
+        tex_content = obj
+
+    elif isinstance(obj, pd.DataFrame):
+        # DataFrame to LaTeX table
+        tex_content = _dataframe_to_latex(
+            obj,
+            caption=caption,
+            label=label,
+            longtable=longtable,
+            escape=escape,
+            **kwargs
+        )
+
+    elif isinstance(obj, (dict, list)):
+        # Try to convert using stats module's convert_results
+        try:
+            from ...stats.utils._normalizers import convert_results
+            tex_content = convert_results(obj, return_as='latex', **kwargs)
+
+            # Add caption and label if provided
+            if caption or label:
+                tex_content = _wrap_with_table_env(tex_content, caption, label)
+
+        except ImportError:
+            warnings.warn(
+                "Cannot convert dict/list to LaTeX: "
+                "scitex.stats.utils.convert_results not available. "
+                "Converting to string instead."
+            )
+            tex_content = str(obj)
+        except Exception as e:
+            warnings.warn(
+                f"Failed to convert object to LaTeX: {e}. "
+                f"Converting to string instead."
+            )
+            tex_content = str(obj)
+
+    else:
+        # Fallback: convert to string
+        warnings.warn(
+            f"Unsupported type {type(obj)} for LaTeX export. "
+            f"Converting to string."
+        )
+        tex_content = str(obj)
+
+    # Wrap in document structure if requested
+    if document:
+        tex_content = _wrap_in_document(tex_content)
+
+    # Write to file
+    with open(spath, 'w') as f:
+        f.write(tex_content)
+
+
+def _dataframe_to_latex(
+    df: 'pd.DataFrame',
+    caption: Optional[str] = None,
+    label: Optional[str] = None,
+    longtable: bool = False,
+    escape: bool = True,
+    **kwargs
+) -> str:
+    """
+    Convert pandas DataFrame to LaTeX table.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame to convert
+    caption : str, optional
+        Table caption
+    label : str, optional
+        Table label for referencing
+    longtable : bool
+        Use longtable environment for multi-page tables
+    escape : bool
+        Escape special LaTeX characters
+    **kwargs
+        Additional arguments for df.to_latex()
+
+    Returns
+    -------
+    str
+        LaTeX table string
+    """
+    import pandas as pd
+
+    # Build to_latex arguments
+    latex_kwargs = {
+        'index': False,
+        'escape': escape,
+    }
+
+    if longtable:
+        latex_kwargs['longtable'] = True
+
+    if caption:
+        latex_kwargs['caption'] = caption
+
+    if label:
+        latex_kwargs['label'] = label
+
+    # Merge with user kwargs
+    latex_kwargs.update(kwargs)
+
+    # Convert to LaTeX
+    return df.to_latex(**latex_kwargs)
+
+
+def _wrap_with_table_env(
+    content: str,
+    caption: Optional[str] = None,
+    label: Optional[str] = None
+) -> str:
+    """
+    Wrap LaTeX content in table environment with caption and label.
+
+    Parameters
+    ----------
+    content : str
+        LaTeX content to wrap
+    caption : str, optional
+        Table caption
+    label : str, optional
+        Table label
+
+    Returns
+    -------
+    str
+        Wrapped LaTeX content
+    """
+    lines = ['\\begin{table}[htbp]', '\\centering']
+
+    if caption:
+        lines.append(f'\\caption{{{caption}}}')
+
+    if label:
+        lines.append(f'\\label{{{label}}}')
+
+    lines.append(content)
+    lines.append('\\end{table}')
+
+    return '\n'.join(lines)
+
+
+def _wrap_in_document(content: str) -> str:
+    """
+    Wrap LaTeX content in complete document structure.
+
+    Parameters
+    ----------
+    content : str
+        LaTeX content to wrap
+
+    Returns
+    -------
+    str
+        Complete LaTeX document
+    """
+    document_template = r'''\documentclass{article}
+\usepackage{booktabs}
+\usepackage{longtable}
+\usepackage{array}
+\usepackage{multirow}
+\usepackage{geometry}
+\geometry{margin=1in}
+
+\begin{document}
+
+%s
+
+\end{document}
+'''
+    return document_template % content
+
+
+# Alias for consistency with other save modules
+_save_tex = save_tex
+
+# EOF

scitex/io/_save_modules/_yaml.py

@@ -3,17 +3,53 @@
 # Timestamp: "2025-05-16 12:26:16 (ywatanabe)"
 # File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_yaml.py
 
+from pathlib import Path
 from ruamel.yaml import YAML
 
 
+def _convert_paths_to_strings(obj):
+    """
+    Recursively convert pathlib.Path objects to strings and DotDict objects to regular dicts in a data structure.
+    
+    Parameters
+    ----------
+    obj : any
+        The object to process. Can be dict, list, tuple, DotDict, Path, or any other type.
+        
+    Returns
+    -------
+    any
+        Copy of the object with all Path objects converted to strings and DotDict objects converted to regular dicts.
+    """
+    if isinstance(obj, Path):
+        return str(obj)
+    elif hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')):
+        # Handle DotDict or similar objects with to_dict() method
+        dict_obj = obj.to_dict()
+        return _convert_paths_to_strings(dict_obj)
+    elif isinstance(obj, dict):
+        return {key: _convert_paths_to_strings(value) for key, value in obj.items()}
+    elif isinstance(obj, (list, tuple)):
+        converted_list = [_convert_paths_to_strings(item) for item in obj]
+        return tuple(converted_list) if isinstance(obj, tuple) else converted_list
+    else:
+        return obj
+
+
 def _save_yaml(obj, spath):
     """
     Save a Python object as a YAML file.
     
+    Automatically converts any pathlib.Path objects and DotDict objects within 
+    the data structure before serialization, as YAML cannot directly serialize 
+    these complex objects.
+    
     Parameters
     ----------
-    obj : dict
-        The object to serialize to YAML.
+    obj : dict or DotDict
+        The object to serialize to YAML. Can contain pathlib.Path objects and
+        DotDict objects, which will be automatically converted to strings and
+        regular dicts respectively.
     spath : str
         Path where the YAML file will be saved.
         
@@ -21,9 +57,12 @@ def _save_yaml(obj, spath):
     -------
     None
     """
+    # Convert any Path objects to strings before YAML serialization
+    obj_with_strings = _convert_paths_to_strings(obj)
+    
     yaml = YAML()
     yaml.preserve_quotes = True
     yaml.indent(mapping=4, sequence=4, offset=4)
 
     with open(spath, "w") as f:
-        yaml.dump(obj, f)
+        yaml.dump(obj_with_strings, f)

scitex/io/_save_modules/_zarr.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-07-11 15:44:00 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/io/_save_modules/_zarr.py
+# ----------------------------------------
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+# src/scitex/io/_save_modules/_zarr.py
+from typing import Any, Optional
+
+import numpy as np
+import zarr
+from numcodecs import Zstd, LZ4, GZip
+
+
+def _save_zarr(
+    obj: Any,
+    spath: str,
+    key: Optional[str] = None,
+    compressor="zstd",
+    chunks=True,
+    store_type="auto",
+    consolidate_metadata=False,
+    **kwargs,
+):
+    """
+    Save object to Zarr format with automatic chunking and compression.
+
+    Parameters:
+    -----------
+    obj : Any
+        Object to save (dict, array, etc.)
+    spath : str
+        Path to Zarr store (.zarr extension or .zarr.zip)
+    key : str, optional
+        Key/group path within Zarr store
+    compressor : str
+        Compression algorithm ('zstd', 'lz4', 'gzip')
+    chunks : bool or tuple
+        Chunking strategy
+    store_type : str
+        'auto' (detect from extension), 'directory', or 'zip'
+    consolidate_metadata : bool
+        Consolidate metadata to reduce file count (directory stores only)
+    """
+    # Convert to dict if needed
+    if not isinstance(obj, dict):
+        obj = {"data": obj}
+
+    # Determine store type
+    if store_type == "auto":
+        if spath.endswith('.zip') or spath.endswith('.zarr.zip'):
+            store_type = "zip"
+        else:
+            store_type = "directory"
+    
+    # Create appropriate store
+    if store_type == "zip":
+        # Single file ZIP store
+        store = zarr.ZipStore(spath, mode='w')
+        root = zarr.open(store, mode='w')
+    else:
+        # Directory store
+        # Remove file if it exists (tempfile creates files, but zarr needs directories)
+        if os.path.exists(spath) and not os.path.isdir(spath):
+            os.remove(spath)
+        
+        # Open or create Zarr store
+        try:
+            root = zarr.open(spath, mode="a")
+        except:
+            root = zarr.open(spath, mode="w")
+    
+    # Handle compressor configuration
+    if isinstance(compressor, str):
+        compressor_map = {
+            "zstd": Zstd(level=3),
+            "lz4": LZ4(acceleration=1),
+            "gzip": GZip(level=5)
+        }
+        compressor = compressor_map.get(compressor.lower(), Zstd(level=3))
+
+    # Navigate to target group
+    if key:
+        # Create nested groups as needed
+        parts = [p for p in key.split("/") if p]
+        current_group = root
+
+        for part in parts[:-1]:
+            if part not in current_group:
+                current_group = current_group.create_group(part)
+            else:
+                current_group = current_group[part]
+
+        final_key = parts[-1] if parts else ""
+        if final_key:
+            if final_key in current_group:
+                del current_group[final_key]  # Override
+            target_group = current_group.create_group(final_key)
+        else:
+            target_group = current_group
+    else:
+        target_group = root
+
+    # Save datasets
+    for dataset_name, data in obj.items():
+        if isinstance(data, str):
+            # String data
+            target_group.create_dataset(
+                dataset_name,
+                data=np.array(data),
+                compressor=None
+            )
+        elif isinstance(data, (int, float, bool)):
+            # Scalar data - no compression needed
+            target_group.create_dataset(
+                dataset_name, data=data
+            )
+        else:
+            # Array data
+            data_array = np.asarray(data)
+
+            if data_array.dtype == np.object_:
+                # Complex objects - pickle them
+                import pickle
+
+                pickled_data = pickle.dumps(data)
+                dataset = target_group.create_dataset(
+                    dataset_name,
+                    data=np.frombuffer(pickled_data, dtype=np.uint8),
+                    compressor=compressor,
+                )
+                dataset.attrs["_type"] = "pickled"
+            else:
+                # Regular array data
+                target_group.create_dataset(
+                    dataset_name,
+                    data=data_array,
+                    chunks=chunks,
+                    compressor=compressor,
+                    **kwargs,
+                )
+
+    # Close ZIP store if needed
+    if store_type == "zip":
+        store.close()
+    
+    # Consolidate metadata if requested (directory stores only)
+    if store_type == "directory" and consolidate_metadata:
+        try:
+            zarr.consolidate_metadata(spath)
+            print(f"✅ Saved to Zarr (consolidated): {spath}" + (f"/{key}" if key else ""))
+        except:
+            print(f"✅ Saved to Zarr: {spath}" + (f"/{key}" if key else ""))
+    else:
+        print(f"✅ Saved to Zarr ({store_type}): {spath}" + (f"/{key}" if key else ""))
+
+# EOF

scitex/io/utils/__init__.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-07-12 05:30:00 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/io/utils/__init__.py
+# ----------------------------------------
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+IO utility functions for SciTeX.
+"""
+
+from .h5_to_zarr import migrate_h5_to_zarr, migrate_h5_to_zarr_batch
+
+__all__ = [
+    "migrate_h5_to_zarr",
+    "migrate_h5_to_zarr_batch",
+]