scitex 2.0.0__py2.py3-none-any.whl

scitex/io/_save_modules/_csv.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-16 12:12:18 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_csv.py
+
+import os
+import pandas as pd
+import numpy as np
+
+
+def _save_csv(obj, spath: str, **kwargs) -> None:
+    """
+    Save data to a CSV file, handling various input types appropriately.
+    
+    Parameters
+    ----------
+    obj : Any
+        The object to save. Can be DataFrame, Series, ndarray, list, tuple, dict, or scalar.
+    spath : str
+        Path where the CSV file will be saved.
+    **kwargs : dict
+        Additional keyword arguments to pass to the pandas to_csv method.
+        
+    Returns
+    -------
+    None
+    
+    Raises
+    ------
+    ValueError
+        If the object type cannot be converted to CSV format.
+    """
+    # Check if path already exists
+    if os.path.exists(spath):
+        # Calculate hash of new data
+        data_hash = None
+
+        # Process based on type
+        if isinstance(obj, (pd.Series, pd.DataFrame)):
+            data_hash = hash(obj.to_string())
+        elif isinstance(obj, np.ndarray):
+            data_hash = hash(pd.DataFrame(obj).to_string())
+        else:
+            # For other types, create a string representation and hash it
+            try:
+                data_str = str(obj)
+                data_hash = hash(data_str)
+            except:
+                # If we can't hash it, proceed with saving
+                pass
+
+        # Compare with existing file if hash calculation was successful
+        if data_hash is not None:
+            try:
+                existing_df = pd.read_csv(spath)
+                existing_hash = hash(existing_df.to_string())
+
+                # Skip if hashes match
+                if existing_hash == data_hash:
+                    return
+            except:
+                # If reading fails, proceed with saving
+                pass
+
+    # Set default index=False if not explicitly specified in kwargs
+    if 'index' not in kwargs:
+        kwargs['index'] = False
+        
+    # Save the file based on type
+    if isinstance(obj, (pd.Series, pd.DataFrame)):
+        obj.to_csv(spath, **kwargs)
+    elif isinstance(obj, np.ndarray):
+        pd.DataFrame(obj).to_csv(spath, **kwargs)
+    elif isinstance(obj, (int, float)):
+        pd.DataFrame([obj]).to_csv(spath, **kwargs)
+    elif isinstance(obj, (list, tuple)):
+        if all(isinstance(x, (int, float)) for x in obj):
+            pd.DataFrame(obj).to_csv(spath, **kwargs)
+        elif all(isinstance(x, pd.DataFrame) for x in obj):
+            pd.concat(obj).to_csv(spath, **kwargs)
+        else:
+            pd.DataFrame({"data": obj}).to_csv(spath, **kwargs)
+    elif isinstance(obj, dict):
+        pd.DataFrame.from_dict(obj).to_csv(spath, **kwargs)
+    else:
+        try:
+            pd.DataFrame({"data": [obj]}).to_csv(spath, **kwargs)
+        except:
+            raise ValueError(f"Unable to save type {type(obj)} as CSV")

scitex/io/_save_modules/_excel.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-06-12 12:59:00 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/.claude-worktree/scitex_repo/src/scitex/io/_save_modules/_excel.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/io/_save_modules/_excel.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+Excel saving functionality for scitex.io.save
+"""
+
+import pandas as pd
+import numpy as np
+
+
+def save_excel(obj, spath, **kwargs):
+    """Handle Excel file saving.
+    
+    Parameters
+    ----------
+    obj : pd.DataFrame, dict, or np.ndarray
+        Object to save as Excel file
+    spath : str
+        Path where Excel file will be saved
+    **kwargs
+        Additional keyword arguments passed to pandas.DataFrame.to_excel()
+        
+    Raises
+    ------
+    ValueError
+        If object type cannot be saved as Excel file
+    """
+    if isinstance(obj, pd.DataFrame):
+        obj.to_excel(spath, index=False, **kwargs)
+    elif isinstance(obj, dict):
+        df = pd.DataFrame(obj)
+        df.to_excel(spath, index=False, **kwargs)
+    elif isinstance(obj, np.ndarray):
+        df = pd.DataFrame(obj)
+        df.to_excel(spath, index=False, **kwargs)
+    else:
+        raise ValueError(f"Cannot save object of type {type(obj)} as Excel file")
+
+
+# EOF

scitex/io/_save_modules/_hdf5.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-06-14 18:26:02 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/SciTeX-Code/src/scitex/io/_save_modules/_hdf5.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/io/_save_modules/_hdf5.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+def _save_hdf5(obj, spath, key=None, override=False, **kwargs):
+    import os
+    import pickle
+
+    import h5py
+    import numpy as np
+
+    if not isinstance(obj, dict):
+        obj = {"data": obj}
+
+    if "compression" not in kwargs:
+        kwargs["compression"] = "gzip"
+
+    mode = "a"
+
+    with h5py.File(spath, mode) as h5_file:
+        if key:
+            # Check if the full path exists
+            key_exists = False
+            try:
+                parts = key.split("/")
+                current = h5_file
+                for part in parts:
+                    if part in current:
+                        current = current[part]
+                    else:
+                        break
+                else:
+                    key_exists = True
+            except:
+                key_exists = False
+            
+            if not override and key_exists:
+                return
+
+            if override and key_exists:
+                del h5_file[key]
+
+            key_parts = key.split("/")
+            current_group = h5_file
+
+            for part in key_parts[:-1]:
+                if part:
+                    current_group = current_group.require_group(part)
+
+            final_key = key_parts[-1] if key_parts[-1] else ""
+            target_group = (
+                current_group.create_group(final_key)
+                if final_key
+                else current_group
+            )
+        else:
+            target_group = h5_file
+
+        for dataset_name, data in obj.items():
+            if isinstance(data, str):
+                target_group.create_dataset(
+                    dataset_name, data=data, dtype=h5py.string_dtype()
+                )
+            else:
+                data_array = np.asarray(data)
+
+                if data_array.dtype == np.object_:
+                    pickled_data = pickle.dumps(data)
+                    target_group.create_dataset(
+                        dataset_name, data=np.void(pickled_data)
+                    )
+                elif data_array.ndim == 0:
+                    target_group.create_dataset(dataset_name, data=data)
+                else:
+                    target_group.create_dataset(
+                        dataset_name, data=data, **kwargs
+                    )
+
+
+# def _save_hdf5(obj, spath, key=None, **kwargs):
+#     """
+#     Save a dictionary of arrays or a single array to an HDF5 file.
+
+#     Parameters
+#     ----------
+#     obj : dict or array-like
+#         Dictionary of arrays to save (keys will be dataset names) or
+#         a single array/data to save (will be saved as 'data').
+#     spath : str
+#         Path where the HDF5 file will be saved.
+#     key : str, optional
+#         Path/key within the HDF5 file where data will be saved.
+#         If None, saves to root.
+#     **kwargs : dict
+#         Additional keyword arguments passed to create_dataset.
+#         Common: compression='gzip', compression_opts=9, shuffle=True
+
+#     Returns
+#     -------
+#     None
+#     """
+#     import numpy as np
+
+#     # Convert single array to dict
+#     if not isinstance(obj, dict):
+#         obj = {'data': obj}
+
+#     # Set default compression if not specified
+#     if "compression" not in kwargs:
+#         kwargs["compression"] = "gzip"
+
+#     mode = "a" if key else "w"
+
+#     with h5py.File(spath, mode) as hf:
+#         if key:
+#             if key in hf:
+#                 del hf[key]
+#             group = hf.create_group(key)
+#         else:
+#             group = hf
+
+#         for name, data in obj.items():
+#             try:
+#                 # Check if data is scalar and remove incompatible options
+#                 if np.isscalar(data) or (isinstance(data, np.ndarray) and data.ndim == 0):
+#                     # Remove chunk/compression options for scalars
+#                     scalar_kwargs = {k: v for k, v in kwargs.items()
+#                                    if k not in ['chunks', 'compression', 'compression_opts',
+#                                                'shuffle', 'fletcher32', 'maxshape']}
+#                     group.create_dataset(name, data=data, **scalar_kwargs)
+#                 else:
+#                     group.create_dataset(name, data=data, **kwargs)
+#             except TypeError as e:
+#                 if "Object dtype" in str(
+#                     e
+#                 ) or "has no native HDF5 equivalent" in str(e):
+#                     if isinstance(data, np.ndarray) and data.dtype == object:
+#                         if all(isinstance(item, str) for item in data.flat):
+#                             dt = h5py.string_dtype(encoding="utf-8")
+#                             group.create_dataset(
+#                                 name, data=data.astype(dt), **kwargs
+#                             )
+#                         else:
+#                             str_data = np.array(
+#                                 [str(item) for item in data.flat]
+#                             ).reshape(data.shape)
+#                             dt = h5py.string_dtype(encoding="utf-8")
+#                             group.create_dataset(
+#                                 name, data=str_data, dtype=dt, **kwargs
+#                             )
+#                     else:
+#                         group.attrs[name] = str(data)
+#                 else:
+#                     raise
+
+# #!/usr/bin/env python3
+# # -*- coding: utf-8 -*-
+# # Timestamp: "2025-05-16 12:24:04 (ywatanabe)"
+# # File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_hdf5.py
+
+# import h5py
+
+# def _save_hdf5(obj, spath, key=None, **kwargs):
+#     """
+#     Save a dictionary of arrays to an HDF5 file.
+
+#     Parameters
+#     ----------
+#     obj : dict
+#         Dictionary of arrays to save. Keys will be dataset names.
+#     spath : str
+#         Path where the HDF5 file will be saved.
+#     key : str, optional
+#         Path to the group within the HDF5 file. If None, saves to root.
+#     **kwargs : dict
+#         Additional keyword arguments passed to create_dataset.
+
+#     Returns
+#     -------
+#     None
+#     """
+#     import numpy as np
+
+#     name_list, obj_list = [], []
+#     for k, v in obj.items():
+#         name_list.append(k)
+#         obj_list.append(v)
+
+#     with h5py.File(spath, "w") as hf:
+#         # If key is specified, create/get the group
+#         if key:
+#             group = hf.require_group(key)
+#         else:
+#             group = hf
+
+#         for name, data in zip(name_list, obj_list):
+#             try:
+#                 # Try to save directly
+#                 group.create_dataset(name, data=data, **kwargs)
+#             except TypeError as e:
+#                 if "Object dtype" in str(
+#                     e
+#                 ) or "has no native HDF5 equivalent" in str(e):
+#                     # Handle object dtype by converting to appropriate format
+#                     if isinstance(data, np.ndarray) and data.dtype == object:
+#                         # Try to convert to string array
+#                         try:
+#                             # Check if all elements are strings
+#                             if all(
+#                                 isinstance(item, str) for item in data.flat
+#                             ):
+#                                 # Save as variable-length string
+#                                 dt = h5py.string_dtype(encoding="utf-8")
+#                                 group.create_dataset(
+#                                     name, data=data.astype(dt), **kwargs
+#                                 )
+#                             else:
+#                                 # Convert to string representation
+#                                 str_data = np.array(
+#                                     [str(item) for item in data.flat]
+#                                 ).reshape(data.shape)
+#                                 dt = h5py.string_dtype(encoding="utf-8")
+#                                 group.create_dataset(
+#                                     name, data=str_data, dtype=dt, **kwargs
+#                                 )
+#                         except Exception:
+#                             # If conversion fails, save as attributes or skip
+#                             group.attrs[name] = str(data)
+#                             print(
+#                                 f"Warning: Dataset '{name}' saved as attribute due to incompatible dtype"
+#                             )
+#                     else:
+#                         # For non-array objects, save as attribute
+#                         group.attrs[name] = str(data)
+#                         print(
+#                             f"Warning: Dataset '{name}' saved as attribute due to incompatible type"
+#                         )
+#                 else:
+#                     raise  # Re-raise if it's a different error
+
+# EOF

scitex/io/_save_modules/_html.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-06-12 13:45:00 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/.claude-worktree/scitex_repo/src/scitex/io/_save_modules/_html.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/io/_save_modules/_html.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+HTML saving functionality for scitex.io.save
+"""
+
+import plotly
+
+
+def save_html(obj, spath, **kwargs):
+    """Handle HTML file saving (primarily for Plotly figures).
+    
+    Parameters
+    ----------
+    obj : plotly.graph_objs.Figure or str
+        Plotly figure object or HTML string to save
+    spath : str
+        Path where HTML file will be saved
+    **kwargs
+        Additional keyword arguments passed to plotly.io.write_html()
+        
+    Notes
+    -----
+    - Primarily designed for saving Plotly interactive figures
+    - Can also save raw HTML strings
+    """
+    if hasattr(obj, 'write_html'):
+        # Plotly figure object
+        obj.write_html(spath, **kwargs)
+    elif isinstance(obj, str):
+        # Raw HTML string
+        with open(spath, 'w') as f:
+            f.write(obj)
+    else:
+        # Try to convert to HTML using plotly
+        plotly.io.write_html(obj, spath, **kwargs)
+
+
+# EOF

scitex/io/_save_modules/_image.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-18 14:52:34 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/io/_save_modules/_save_image.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/io/_save_modules/_save_image.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import io as _io
+
+import plotly
+from PIL import Image
+
+
+def save_image(obj, spath, **kwargs):
+    # png
+    if spath.endswith(".png"):
+        # plotly
+        if isinstance(obj, plotly.graph_objs.Figure):
+            obj.write_image(file=spath, format="png")
+        # PIL image
+        elif isinstance(obj, Image.Image):
+            obj.save(spath)
+        # matplotlib
+        else:
+            try:
+                obj.savefig(spath)
+            except:
+                obj.figure.savefig(spath)
+        del obj
+
+    # tiff
+    elif spath.endswith(".tiff") or spath.endswith(".tif"):
+        # PIL image
+        if isinstance(obj, Image.Image):
+            obj.save(spath)
+        # matplotlib
+        else:
+            try:
+                obj.savefig(spath, dpi=300, format="tiff")
+            except:
+                obj.figure.savefig(spath, dpi=300, format="tiff")
+
+        del obj
+
+    # jpeg
+    elif spath.endswith(".jpeg") or spath.endswith(".jpg"):
+        buf = _io.BytesIO()
+
+        # plotly
+        if isinstance(obj, plotly.graph_objs.Figure):
+            obj.write_image(buf, format="png")
+            buf.seek(0)
+            img = Image.open(buf)
+            img.convert("RGB").save(spath, "JPEG")
+            buf.close()
+
+        # PIL image
+        elif isinstance(obj, Image.Image):
+            obj.save(spath)
+
+        # matplotlib
+        else:
+            try:
+                obj.savefig(buf, format="png")
+            except:
+                obj.figure.savefig(buf, format="png")
+
+            buf.seek(0)
+            img = Image.open(buf)
+            img.convert("RGB").save(spath, "JPEG")
+            buf.close()
+        del obj
+
+    # GIF
+    elif spath.endswith(".gif"):
+        # PIL image
+        if isinstance(obj, Image.Image):
+            obj.save(spath, save_all=True)
+        # plotly - convert via PNG first
+        elif isinstance(obj, plotly.graph_objs.Figure):
+            buf = _io.BytesIO()
+            obj.write_image(buf, format="png")
+            buf.seek(0)
+            img = Image.open(buf)
+            img.save(spath, "GIF")
+            buf.close()
+        # matplotlib
+        else:
+            buf = _io.BytesIO()
+            try:
+                obj.savefig(buf, format="png")
+            except:
+                obj.figure.savefig(buf, format="png")
+            buf.seek(0)
+            img = Image.open(buf)
+            img.save(spath, "GIF")
+            buf.close()
+        del obj
+
+    # SVG
+    elif spath.endswith(".svg"):
+        # Plotly
+        if isinstance(obj, plotly.graph_objs.Figure):
+            obj.write_image(file=spath, format="svg")
+        # Matplotlib
+        else:
+            try:
+                obj.savefig(spath, format="svg")
+            except AttributeError:
+                obj.figure.savefig(spath, format="svg")
+        del obj
+
+    # PDF
+    elif spath.endswith(".pdf"):
+        # Plotly
+        if isinstance(obj, plotly.graph_objs.Figure):
+            obj.write_image(file=spath, format="pdf")
+        # PIL Image - convert to PDF
+        elif isinstance(obj, Image.Image):
+            # Convert RGBA to RGB if needed
+            if obj.mode == 'RGBA':
+                rgb_img = Image.new('RGB', obj.size, (255, 255, 255))
+                rgb_img.paste(obj, mask=obj.split()[3])
+                rgb_img.save(spath, "PDF")
+            else:
+                obj.save(spath, "PDF")
+        # Matplotlib
+        else:
+            try:
+                obj.savefig(spath, format="pdf")
+            except AttributeError:
+                obj.figure.savefig(spath, format="pdf")
+        del obj
+
+# EOF

scitex/io/_save_modules/_joblib.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-16 12:22:56 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_joblib.py
+
+import joblib
+
+
+def _save_joblib(obj, spath):
+    """
+    Save an object using joblib serialization.
+    
+    Parameters
+    ----------
+    obj : Any
+        Object to serialize.
+    spath : str
+        Path where the joblib file will be saved.
+        
+    Returns
+    -------
+    None
+    """
+    with open(spath, "wb") as s:
+        joblib.dump(obj, s, compress=3)

scitex/io/_save_modules/_json.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-16 12:27:18 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/io/_save_modules/_json.py
+
+import json
+
+
+def _save_json(obj, spath):
+    """
+    Save a Python object as a JSON file.
+    
+    Parameters
+    ----------
+    obj : dict or list
+        The object to serialize to JSON.
+    spath : str
+        Path where the JSON file will be saved.
+        
+    Returns
+    -------
+    None
+    """
+    with open(spath, "w") as f:
+        json.dump(obj, f, indent=4)

scitex/io/_save_modules/_listed_dfs_as_csv.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-18 14:52:59 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/io/_save_modules/_save_listed_dfs_as_csv.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/io/_save_modules/_save_listed_dfs_as_csv.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+# Time-stamp: "2024-11-02 21:28:56 (ywatanabe)"
+
+import csv
+
+import numpy as np
+
+from .._mv_to_tmp import _mv_to_tmp
+
+
+
+def _save_listed_dfs_as_csv(
+    listed_dfs,
+    spath_csv,
+    indi_suffix=None,
+    overwrite=False,
+    verbose=False,
+):
+    """listed_dfs:
+        [df1, df2, df3, ..., dfN]. They will be written vertically in the order.
+
+    spath_csv:
+        /hoge/fuga/foo.csv
+
+    indi_suffix:
+        At the left top cell on the output csv file, '{}'.format(indi_suffix[i])
+        will be added, where i is the index of the df.On the other hand,
+        when indi_suffix=None is passed, only '{}'.format(i) will be added.
+    """
+
+    if overwrite == True:
+        _mv_to_tmp(spath_csv, L=2)
+
+    indi_suffix = np.arange(len(listed_dfs)) if indi_suffix is None else indi_suffix
+    for i, df in enumerate(listed_dfs):
+        with open(spath_csv, mode="a") as f:
+            f_writer = csv.writer(f)
+            i_suffix = indi_suffix[i]
+            f_writer.writerow(["{}".format(indi_suffix[i])])
+        df.to_csv(spath_csv, mode="a", index=True, header=True)
+        with open(spath_csv, mode="a") as f:
+            f_writer = csv.writer(f)
+            f_writer.writerow([""])
+    if verbose:
+        print("Saved to: {}".format(spath_csv))
+
+# EOF