scitex 2.0.0__py2.py3-none-any.whl

scitex/dt/_linspace.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-04-23 10:42:43 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/dt/_linspace.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/dt/_linspace.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from typing import Union, Optional, List, Any
+import numpy as np
+import datetime
+from datetime import timedelta
+
+
+def linspace(
+    start_dt: datetime.datetime,
+    end_dt: datetime.datetime,
+    n_samples: Optional[int] = None,
+    sampling_rate: Optional[float] = None,
+) -> np.ndarray:
+    """
+    Create a linearly spaced array between two datetime objects.
+
+    Args:
+        start_dt: Starting datetime object
+        end_dt: Ending datetime object
+        n_samples: Number of samples to create (mutually exclusive with sampling_rate)
+        sampling_rate: Sampling rate in Hz (mutually exclusive with n_samples)
+
+    Returns:
+        Array of datetime objects evenly spaced between start_dt and end_dt
+    """
+    # Type checking
+    if not isinstance(start_dt, datetime.datetime):
+        raise TypeError(f"start_dt must be a datetime object, got {type(start_dt)}")
+
+    if not isinstance(end_dt, datetime.datetime):
+        raise TypeError(f"end_dt must be a datetime object, got {type(end_dt)}")
+
+    if n_samples is not None and not isinstance(n_samples, (int, float)):
+        raise TypeError(f"n_samples must be a number, got {type(n_samples)}")
+
+    if sampling_rate is not None and not isinstance(sampling_rate, (int, float)):
+        raise TypeError(f"sampling_rate must be a number, got {type(sampling_rate)}")
+
+    if start_dt >= end_dt:
+        raise ValueError("start_dt must be earlier than end_dt")
+
+    duration_seconds = (end_dt - start_dt).total_seconds()
+
+    if n_samples is not None and sampling_rate is not None:
+        raise ValueError("Provide either n_samples or sampling_rate, not both")
+
+    if n_samples is None and sampling_rate is None:
+        raise ValueError("Either n_samples or sampling_rate must be provided")
+
+    if sampling_rate is not None:
+        if sampling_rate <= 0:
+            raise ValueError("sampling_rate must be positive")
+        n_samples = int(duration_seconds * sampling_rate) + 1
+    else:
+        if n_samples <= 0:
+            raise ValueError("n_samples must be positive")
+
+    # Create linear space in seconds
+    seconds_array = np.linspace(0, duration_seconds, n_samples)
+
+    # Convert to datetime objects
+    datetime_array = np.array(
+        [start_dt + timedelta(seconds=float(sec)) for sec in seconds_array]
+    )
+
+    return datetime_array
+
+
+# #!/usr/bin/env python3
+# # -*- coding: utf-8 -*-
+# # Timestamp: "2025-04-23 10:38:20 (ywatanabe)"
+# # File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/dt/_linspace.py
+# # ----------------------------------------
+# import os
+# __FILE__ = (
+#     "./src/scitex/dt/_linspace.py"
+# )
+# __DIR__ = os.path.dirname(__FILE__)
+# # ----------------------------------------
+
+# import numpy as np
+# from datetime import timedelta
+
+# def linspace(start_dt, end_dt, n_samples=None, sampling_rate=None):
+#     """
+#     Create a linearly spaced array between two datetime objects.
+
+#     Args:
+#         start_dt: Starting datetime object
+#         end_dt: Ending datetime object
+#         n_samples: Number of samples to create (mutually exclusive with sampling_rate)
+#         sampling_rate: Sampling rate in Hz (mutually exclusive with n_samples)
+
+#     Returns:
+#         Array of datetime objects evenly spaced between start_dt and end_dt
+#     """
+
+#     duration_seconds = (end_dt - start_dt).total_seconds()
+
+#     if n_samples is not None and sampling_rate is not None:
+#         raise ValueError("Provide either n_samples or sampling_rate, not both")
+
+#     if n_samples is None and sampling_rate is None:
+#         raise ValueError("Either n_samples or sampling_rate must be provided")
+
+#     if sampling_rate is not None:
+#         n_samples = int(duration_seconds * sampling_rate) + 1
+
+
+#     # Create linear space in seconds
+#     seconds_array = np.linspace(0, duration_seconds, n_samples)
+
+#     # Convert to datetime objects
+#     datetime_array = np.array([start_dt + timedelta(seconds=float(sec)) for sec in seconds_array])
+
+#     return datetime_array
+
+# # EOF
+
+# EOF

scitex/etc/__init__.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2025-01-09 08:45:00 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/.claude-worktree/scitex_repo/src/scitex/etc/__init__.py
+
+"""
+Utility functions for miscellaneous tasks.
+
+This module provides utility functions that don't fit into other categories,
+such as keyboard input handling for interactive programs.
+"""
+
+from .wait_key import wait_key, count
+
+__all__ = ["wait_key", "count"]

scitex/etc/wait_key.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2023-03-24 23:13:32 (ywatanabe)"
+
+import readchar
+import time
+import multiprocessing
+
+
+def wait_key(p):
+    key = "x"
+    while key != "q":
+        key = readchar.readchar()
+        print(key)
+    print("q was pressed.")
+    p.terminate()
+    # event.set()
+    # raise Exception
+
+
+def count():
+    counter = 0
+    while True:
+        print(counter)
+        time.sleep(1)
+        counter += 1
+
+
+if __name__ == "__main__":
+    p1 = multiprocessing.Process(target=count)
+
+    p1.start()
+    waitKey(p1)
+    print("aaa")

scitex/gen/_DimHandler.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-05 00:39:26 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/gen/_DimHandler.py
+
+"""
+This script demonstrates DimHandler, which:
+1) Keeps designated dimensions,
+2) Permutes the kept dimensions to the last while maintaining their relative order,
+3) Reshapes the remaining dimensions to the first, batch dimension,
+4) (Performs calculations),
+5) Restores the summarized dimensions to their original shapes.
+"""
+
+# Imports
+import sys
+
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+
+
+# Functions
+class DimHandler:
+    """
+    A utility class for handling dimension manipulations on tensors or arrays, including reshaping and permuting dimensions.
+
+    Attributes:
+        orig_shape (tuple): The original shape of the input tensor or array before any manipulation.
+        keepdims (list): The list of dimensions to be kept and moved to the end.
+        n_non_keepdims (list): The sizes of the dimensions not kept, used for reshaping back to the original shape.
+        n_keepdims (list): The sizes of the kept dimensions, used for reshaping.
+
+    Example1:
+        import torch
+
+        dh = DimHandler()
+        x = torch.rand(1, 2, 3, 4, 5, 6)  # Example tensor
+        print(x.shape)  # torch.Size([1, 2, 3, 4, 5, 6])
+        x = dh.fit(x, keepdims=[0, 2, 5])
+        print(x.shape)  # torch.Size([40, 1, 3, 6])
+        x = dh.unfit(x)
+        print(x.shape)  # torch.Size([2, 4, 5, 1, 3, 6])
+
+    Example 2:
+        import torch
+
+        dh = DimHandler()
+        x = torch.rand(1, 2, 3, 4, 5, 6)  # Example tensor
+        print(x.shape)  # torch.Size([1, 2, 3, 4, 5, 6])
+        x = dh.fit(x, keepdims=[0, 2, 5])
+        print(x.shape)  # torch.Size([40, 1, 3, 6])
+        y = x.mean(axis=-2) # calculation on the kept dims
+        print(y.shape) # torch.Size([40, 1, 6])
+        y = dh.unfit(y)
+        print(y.shape) # torch.Size([2, 4, 5, 1, 6])
+    """
+
+    def __init__(self):
+        pass
+        # self.orig_shape = None
+        # self.keepdims = None
+
+    def fit(self, x, keepdims=[]):
+        if isinstance(x, np.ndarray):
+            return self._fit_numpy(x, keepdims=keepdims)
+        elif isinstance(x, torch.Tensor):
+            return self._fit_torch(x, keepdims=keepdims)
+
+    def _fit_numpy(self, x, keepdims=[]):
+        """
+        Reshapes the input NumPy array by flattening the dimensions not in `keepdims` and moving the kept dimensions to the end.
+
+        Arguments:
+            x (numpy.ndarray): The input array to be reshaped.
+            keepdims (list of int): The indices of the dimensions to keep.
+
+        Returns:
+            x_flattened (numpy.ndarray): The reshaped array with kept dimensions moved to the end.
+        """
+        assert len(keepdims) <= len(
+            x.shape
+        ), "keepdims cannot have more dimensions than the array itself."
+
+        # Normalize negative indices to positive indices
+        total_dims = len(x.shape)
+        keepdims = [dim if dim >= 0 else total_dims + dim for dim in keepdims]
+        keepdims = sorted(set(keepdims))
+
+        self.shape_fit = x.shape
+
+        non_keepdims = [ii for ii in range(len(self.shape_fit)) if ii not in keepdims]
+
+        self.n_non_keepdims = [self.shape_fit[nkd] for nkd in non_keepdims]
+        self.n_keepdims = [self.shape_fit[kd] for kd in keepdims]
+
+        # Permute the array dimensions so that the non-kept dimensions come first
+        new_order = non_keepdims + keepdims
+        x_permuted = np.transpose(x, axes=new_order)
+
+        # Flatten the non-kept dimensions
+        x_flattened = x_permuted.reshape(-1, *self.n_keepdims)
+
+        return x_flattened
+
+    def _fit_torch(self, x, keepdims=[]):
+        """
+        Reshapes the input tensor or array by flattening the dimensions not in `keepdims` and moving the kept dimensions to the end.
+
+        Arguments:
+            x (torch.Tensor): The input tensor or array to be reshaped.
+            keepdims (list of int): The indices of the dimensions to keep.
+
+        Returns:
+            x_flattend (torch.Tensor): The reshaped tensor or array with kept dimensions moved to the end.
+
+        Note:
+            This method modifies the `orig_shape`, `keepdims`, `n_non_keepdims`, and `n_keepdims` attributes based on the input.
+        """
+        assert len(keepdims) <= len(
+            x.shape
+        ), "keepdims cannot have more dimensions than the tensor itself."
+
+        keepdims = torch.tensor(keepdims).clone().detach().cpu().int()
+        # Normalize negative indices to positive indices
+        total_dims = len(x.shape)
+        keepdims = [dim if dim >= 0 else total_dims + dim for dim in keepdims]
+        keepdims = sorted(set(keepdims))
+
+        self.shape_fit = x.shape
+
+        non_keepdims = [
+            int(ii) for ii in torch.arange(len(self.shape_fit)) if ii not in keepdims
+        ]
+
+        self.n_non_keepdims = [self.shape_fit[nkd] for nkd in non_keepdims]
+        self.n_keepdims = [self.shape_fit[kd] for kd in keepdims]
+
+        x_permuted = x.permute(*non_keepdims, *keepdims)
+        x_flattend = x_permuted.reshape(-1, *self.n_keepdims)
+
+        return x_flattend
+
+    def unfit(self, y):
+        """
+        Restores the first dimension of reshaped tensor or array back to its original shape before the `fit` operation.
+
+        Arguments:
+            y (torch.Tensor or numpy.array): The tensor or array to be restored to its original shape.
+
+        Returns:
+            y_restored (torch.Tensor or numpy.array): The tensor or array restored to its original shape.
+        """
+        self.shape_unfit = y.shape
+        return y.reshape(*self.n_non_keepdims, *self.shape_unfit[1:])
+
+
+if __name__ == "__main__":
+    import scitex
+
+    # Start
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt)
+
+    # Example1:
+    scitex.gen.printc("Example 1")
+    dh = DimHandler()
+    x = torch.rand(1, 2, 3, 4, 5, 6)  # Example tensor
+    print(x.shape)  # torch.Size([1, 2, 3, 4, 5, 6])
+    x = dh.fit(x, keepdims=[0, 2, 5])
+    print(x.shape)  # torch.Size([40, 1, 3, 6])
+    x = dh.unfit(x)
+    print(x.shape)  # torch.Size([2, 4, 5, 1, 3, 6])
+
+    # Example 2:
+    scitex.gen.printc("Example 2")
+    dh = DimHandler()
+    x = torch.rand(1, 2, 3, 4, 5, 6)  # Example tensor
+    print(x.shape)  # torch.Size([1, 2, 3, 4, 5, 6])
+    x = dh.fit(x, keepdims=[0, 2, 5])
+    print(x.shape)  # torch.Size([40, 1, 3, 6])
+    y = x.mean(axis=-2)  # calculation on the kept dims
+    print(y.shape)  # torch.Size([40, 1, 6])
+    y = dh.unfit(y)
+    print(y.shape)  # torch.Size([2, 4, 5, 1, 6])
+
+    # Close
+    scitex.gen.close(CONFIG)
+
+# EOF
+
+"""
+/ssh:ywatanabe@444:/home/ywatanabe/proj/entrance/scitex/gen/_DimHandler.py
+"""
+
+
+# EOF

scitex/gen/_TimeStamper.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "ywatanabe (2024-11-07 16:06:50)"
+# File: ./scitex_repo/src/scitex/gen/_TimeStamper.py
+
+import time
+from typing import Union, Optional
+import pandas as pd
+
+
+class TimeStamper:
+    """
+    Functionality:
+        * Generates timestamps with comments and tracks elapsed time
+        * Records timestamps in a DataFrame for analysis
+        * Calculates time differences between timestamps
+    Input:
+        * Comments for each timestamp
+        * Format preference (simple or detailed)
+    Output:
+        * Formatted timestamp strings
+        * DataFrame with timestamp records
+        * Time differences between specified timestamps
+    Prerequisites:
+        * pandas
+    """
+
+    def __init__(self, is_simple: bool = True) -> None:
+        self.id: int = -1
+        self.start_time: float = time.time()
+        self._is_simple: bool = is_simple
+        self._prev: float = self.start_time
+        self._df_record: pd.DataFrame = pd.DataFrame(
+            columns=[
+                "timestamp",
+                "elapsed_since_start",
+                "elapsed_since_prev",
+                "comment",
+                "formatted_text",
+            ]
+        )
+
+    def __call__(self, comment: str = "", verbose: bool = False) -> str:
+        now: float = time.time()
+        from_start: float = now - self.start_time
+        from_prev: float = now - self._prev
+
+        formatted_from_start: str = time.strftime("%H:%M:%S", time.gmtime(from_start))
+        formatted_from_prev: str = time.strftime("%H:%M:%S", time.gmtime(from_prev))
+
+        self.id += 1
+        self._prev = now
+
+        text: str = (
+            f"ID:{self.id} | {formatted_from_start} {comment} | "
+            if self._is_simple
+            else f"Time (id:{self.id}): total {formatted_from_start}, prev {formatted_from_prev} [hh:mm:ss]: {comment}\n"
+        )
+
+        self._df_record.loc[self.id] = [
+            now,
+            from_start,
+            from_prev,
+            comment,
+            text,
+        ]
+
+        if verbose:
+            print(text)
+        return text
+
+    @property
+    def record(self) -> pd.DataFrame:
+        """Returns the record DataFrame without the formatted_text column."""
+        return self._df_record[
+            [
+                "timestamp",
+                "elapsed_since_start",
+                "elapsed_since_prev",
+                "comment",
+            ]
+        ]
+
+    def delta(self, id1: int, id2: int) -> float:
+        """Calculates time difference between two timestamps.
+
+        Parameters
+        ----------
+        id1 : int
+            First timestamp ID
+        id2 : int
+            Second timestamp ID
+
+        Returns
+        -------
+        float
+            Time difference in seconds
+
+        Raises
+        ------
+        ValueError
+            If IDs don't exist in records
+        """
+        if id1 < 0:
+            id1 = len(self._df_record) + id1
+        if id2 < 0:
+            id2 = len(self._df_record) + id2
+
+        if not all(idx in self._df_record.index for idx in [id1, id2]):
+            raise ValueError("Invalid timestamp ID(s)")
+
+        return (
+            self._df_record.loc[id1, "timestamp"]
+            - self._df_record.loc[id2, "timestamp"]
+        )
+
+
+if __name__ == "__main__":
+    ts = TimeStamper(is_simple=True)
+    ts("Starting process")
+    time.sleep(1)
+    ts("One second later")
+    time.sleep(2)
+    ts("Two seconds later")
+
+
+# EOF
+
+# #!/usr/bin/env python3
+# # -*- coding: utf-8 -*-
+# # Time-stamp: "ywatanabe (2024-11-07 16:06:50)"
+# # File: ./scitex_repo/src/scitex/gen/_TimeStamper.py
+
+# import time
+# import pandas as pd
+
+
+# class TimeStamper:
+#     """
+#     A class for generating timestamps with optional comments, tracking both the time since object creation and since the last call.
+#     """
+
+#     def __init__(self, is_simple=True):
+#         self.id = -1
+#         self.start_time = time.time()
+#         self._is_simple = is_simple
+#         self._prev = self.start_time
+#         self._df_record = pd.DataFrame(
+#             columns=[
+#                 "timestamp",
+#                 "elapsed_since_start",
+#                 "elapsed_since_prev",
+#                 "comment",
+#                 "formatted_text",
+#             ]
+#         )
+
+#     def __call__(self, comment="", verbose=False):
+#         now = time.time()
+#         from_start = now - self.start_time
+#         from_prev = now - self._prev
+#         formatted_from_start = time.strftime(
+#             "%H:%M:%S", time.gmtime(from_start)
+#         )
+#         formatted_from_prev = time.strftime("%H:%M:%S", time.gmtime(from_prev))
+#         self.id += 1
+#         self._prev = now
+#         text = (
+#             f"ID:{self.id} | {formatted_from_start} {comment} | "
+#             if self._is_simple
+#             else f"Time (id:{self.id}): total {formatted_from_start}, prev {formatted_from_prev} [hh:mm:ss]: {comment}\n"
+#         )
+
+#         # Update DataFrame directly
+#         self._df_record.loc[self.id] = [
+#             now,
+#             from_start,
+#             from_prev,
+#             comment,
+#             text,
+#         ]
+
+#         if verbose:
+#             print(text)
+#         return text
+
+#     @property
+#     def record(self):
+#         return self._df_record[
+#             [
+#                 "timestamp",
+#                 "elapsed_since_start",
+#                 "elapsed_since_prev",
+#                 "comment",
+#             ]
+#         ]
+
+#     def delta(self, id1, id2):
+#         """
+#         Calculate the difference in seconds between two timestamps identified by their IDs.
+
+#         Parameters:
+#             id1 (int): The ID of the first timestamp.
+#             id2 (int): The ID of the second timestamp.
+
+#         Returns:
+#             float: The difference in seconds between the two timestamps.
+
+#         Raises:
+#             ValueError: If either id1 or id2 is not in the DataFrame index.
+#         """
+#         # Adjust for negative indices, similar to negative list indexing in Python
+#         if id1 < 0:
+#             id1 = len(self._df_record) + id1
+#         if id2 < 0:
+#             id2 = len(self._df_record) + id2
+
+#         # Check if both IDs exist in the DataFrame
+#         if (
+#             id1 not in self._df_record.index
+#             or id2 not in self._df_record.index
+#         ):
+#             raise ValueError(
+#                 "One or both of the IDs do not exist in the record."
+#             )
+
+#         # Compute the difference in timestamps
+#         time_diff = (
+#             self._df_record.loc[id1, "timestamp"]
+#             - self._df_record.loc[id2, "timestamp"]
+#         )
+#         return time_diff
+
+
+# if __name__ == "__main__":
+#     ts = TimeStamper(is_simple=True)
+#     ts("Starting process")
+#     time.sleep(1)
+#     ts("One second later")
+#     time.sleep(2)
+#     ts("Two seconds later")
+
+
+# # EOF