scitex 2.8.1__py3-none-any.whl → 2.10.2__py3-none-any.whl

scitex/cli/main.py

@@ -1,13 +1,14 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """
 SciTeX CLI Main Entry Point
 """
 
 import os
 import sys
+
 import click
-from . import cloud, config, scholar, security, web, writer
+
+from . import cloud, config, convert, scholar, security, web, writer
 
 
 @click.group(context_settings={"help_option_names": ["-h", "--help"]})
@@ -39,6 +40,7 @@ def cli():
 # Add command groups
 cli.add_command(cloud.cloud)
 cli.add_command(config.config)
+cli.add_command(convert.convert)
 cli.add_command(scholar.scholar)
 cli.add_command(security.security)
 cli.add_command(web.web)
@@ -130,7 +132,7 @@ def completion(shell, show):
 
     # Check if already installed (and not commented out)
     if os.path.exists(rc_file):
-        with open(rc_file, "r") as f:
+        with open(rc_file) as f:
             for line in f:
                 # Check if the line exists and is not commented
                 stripped = line.strip()
@@ -149,7 +151,7 @@ def completion(shell, show):
         os.makedirs(os.path.dirname(rc_file), exist_ok=True)
 
         with open(rc_file, "a") as f:
-            f.write(f"\n# SciTeX tab completion\n")
+            f.write("\n# SciTeX tab completion\n")
             f.write(f"{eval_line}\n")
 
         click.secho(f"Successfully installed tab completion to {rc_file}", fg="green")

scitex/datetime/__init__.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-05 14:30:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/datetime/__init__.py
+
+"""
+Scitex datetime module.
+
+Provides utilities for datetime operations including:
+- linspace: Create linearly spaced datetime arrays
+- normalize_timestamp: Standardize timestamps to consistent format
+- to_datetime: Convert various formats to datetime objects
+- validate_timestamp_format: Validate timestamp string format
+- format_for_filename: Format timestamps for filenames
+- format_for_display: Format timestamps for display
+- get_time_delta_seconds: Calculate time differences
+"""
+
+from ._linspace import linspace
+from ._normalize_timestamp import (
+    ALTERNATIVE_FORMATS,
+    STANDARD_FORMAT,
+    format_for_display,
+    format_for_filename,
+    get_time_delta_seconds,
+    normalize_timestamp,
+    parse_patient_recording_start_format,
+    to_datetime,
+    validate_timestamp_format,
+)
+
+__all__ = [
+    # Core functions
+    "linspace",
+    "normalize_timestamp",
+    "to_datetime",
+    # Formatting functions
+    "format_for_filename",
+    "format_for_display",
+    "validate_timestamp_format",
+    # Utility functions
+    "get_time_delta_seconds",
+    "parse_patient_recording_start_format",
+    # Constants
+    "STANDARD_FORMAT",
+    "ALTERNATIVE_FORMATS",
+]

scitex/datetime/_linspace.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-05 14:30:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/datetime/_linspace.py
+
+"""
+Datetime linspace utility for creating evenly spaced datetime arrays.
+"""
+
+import datetime
+from datetime import timedelta
+from typing import Optional
+
+import numpy as np
+
+
+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.
+
+    Parameters
+    ----------
+    start_dt : datetime.datetime
+        Starting datetime object
+    end_dt : datetime.datetime
+        Ending datetime object
+    n_samples : int, optional
+        Number of samples to create (mutually exclusive with sampling_rate)
+    sampling_rate : float, optional
+        Sampling rate in Hz (mutually exclusive with n_samples)
+
+    Returns
+    -------
+    np.ndarray
+        Array of datetime objects evenly spaced between start_dt and end_dt
+
+    Raises
+    ------
+    TypeError
+        If start_dt or end_dt is not a datetime object
+    ValueError
+        If start_dt >= end_dt, or if both/neither n_samples and sampling_rate provided
+
+    Examples
+    --------
+    >>> import datetime
+    >>> start = datetime.datetime(2023, 1, 1, 0, 0, 0)
+    >>> end = datetime.datetime(2023, 1, 1, 0, 0, 10)
+    >>> result = linspace(start, end, n_samples=11)
+    >>> len(result)
+    11
+    """
+    # 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
+
+
+# EOF

scitex/datetime/_normalize_timestamp.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-01-05 14:30:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/datetime/_normalize_timestamp.py
+
+"""
+Timestamp Standardization Utilities
+
+Functionality:
+- Standardizes timestamps to consistent format defined in CONFIG.FORMATS.TIMESTAMP
+- Handles various input formats (datetime objects, strings, timestamps)
+- Provides UTC normalization
+- Ensures consistent timestamp formatting across the codebase
+
+Input formats supported:
+- datetime objects (with or without timezone)
+- Unix timestamps (int/float)
+- Various string formats
+
+Output:
+- Standardized timestamp strings in format: "%Y-%m-%d %H:%M:%S.%f"
+- UTC normalized timestamps
+- Validation utilities
+
+Prerequisites:
+- CONFIG.FORMATS.TIMESTAMP for standard format
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime, timezone
+from typing import Union
+
+# Default standard format
+DEFAULT_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+# Try to get standard format from config, fallback to default
+try:
+    import scitex as stx
+
+    CONFIG = stx.io.load_configs()
+    STANDARD_FORMAT = (
+        getattr(getattr(CONFIG, "FORMATS", None), "TIMESTAMP", None) or DEFAULT_FORMAT
+    )
+except Exception:
+    STANDARD_FORMAT = DEFAULT_FORMAT
+
+# Common alternative formats to try when parsing
+ALTERNATIVE_FORMATS = [
+    "%Y-%m-%dT%H:%M:%S.%f",
+    "%Y-%m-%dT%H:%M:%S",  # ISO 8601 with T (no microseconds)
+    "%Y-%m-%d %H:%M:%S.%f",
+    "%Y-%m-%d %H:%M:%S",
+    "%Y/%m/%d %H:%M:%S.%f",
+    "%Y/%m/%d %H:%M:%S",
+    "%d-%m-%Y %H:%M:%S.%f",
+    "%d-%m-%Y %H:%M:%S",
+    "%d/%m/%Y %H:%M:%S.%f",
+    "%d/%m/%Y %H:%M:%S",
+    "%d/%m/%Y, %H:%M:%S",  # Format used in REC_START
+    "%Y%m%d %H:%M:%S.%f",
+    "%Y%m%d %H:%M:%S",
+    "%Y-%m-%d_%H:%M:%S.%f",
+    "%Y-%m-%d_%H:%M:%S",
+]
+
+
+def normalize_timestamp(
+    timestamp: Union[datetime, str, int, float],
+    return_as: str = "str",
+    normalize_utc: bool = True,
+) -> Union[str, datetime, float]:
+    """
+    Standardize any timestamp format to requested output type.
+
+    Parameters
+    ----------
+    timestamp : datetime, str, int, or float
+        Timestamp in any supported format
+    return_as : str
+        Output format: "str" (default), "datetime", or "timestamp"
+    normalize_utc : bool
+        If True, normalize to UTC timezone
+
+    Returns
+    -------
+    str, datetime, or float
+        Standardized timestamp in requested format:
+        - "str": String in CONFIG.FORMATS.TIMESTAMP format
+        - "datetime": datetime object
+        - "timestamp": Unix timestamp (float)
+
+    Examples
+    --------
+    >>> from datetime import datetime
+    >>> dt = datetime(2010, 6, 18, 10, 15, 0)
+    >>> normalize_timestamp(dt, return_as="str", normalize_utc=False)
+    '2010-06-18 10:15:00'
+    """
+    # Convert to datetime object
+    dt = to_datetime(timestamp)
+
+    # Normalize to UTC if requested
+    if normalize_utc:
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        else:
+            dt = dt.astimezone(timezone.utc)
+
+    # Return in requested format
+    if return_as == "str":
+        return dt.strftime(STANDARD_FORMAT)
+    elif return_as == "datetime":
+        return dt
+    elif return_as == "timestamp":
+        return dt.timestamp()
+    else:
+        raise ValueError(
+            f"return_as must be 'str', 'datetime', or 'timestamp', got: {return_as}"
+        )
+
+
+def to_datetime(timestamp: Union[datetime, str, int, float]) -> datetime:
+    """
+    Convert various timestamp formats to datetime object.
+
+    Parameters
+    ----------
+    timestamp : datetime, str, int, or float
+        Timestamp in any supported format
+
+    Returns
+    -------
+    datetime
+        Datetime object
+
+    Raises
+    ------
+    ValueError
+        If string format cannot be parsed
+    TypeError
+        If timestamp type is not supported
+    """
+    # Already datetime
+    if isinstance(timestamp, datetime):
+        return timestamp
+
+    # Unix timestamp (int/float)
+    elif isinstance(timestamp, (int, float)):
+        return datetime.fromtimestamp(timestamp, tz=timezone.utc)
+
+    # String format
+    elif isinstance(timestamp, str):
+        # Handle nanosecond precision by truncating to microseconds
+        if "." in timestamp and len(timestamp.split(".")[-1]) > 6:
+            parts = timestamp.split(".")
+            # Keep only first 6 digits of fractional seconds
+            truncated_microseconds = parts[-1][:6]
+            # Handle cases where there might be additional text after microseconds
+            if not truncated_microseconds.isdigit():
+                # Extract just the digit portion
+                digits = re.match(r"(\d+)", parts[-1])
+                if digits:
+                    truncated_microseconds = digits.group(1)[:6]
+            timestamp = ".".join(parts[:-1] + [truncated_microseconds])
+
+        # Try parsing with various formats
+        for fmt in ALTERNATIVE_FORMATS:
+            try:
+                return datetime.strptime(timestamp, fmt)
+            except ValueError:
+                continue
+
+        # If no format matched, raise error
+        raise ValueError(
+            f"Could not parse timestamp string: {timestamp}. "
+            f"Tried formats: {ALTERNATIVE_FORMATS}"
+        )
+
+    else:
+        raise TypeError(
+            f"timestamp must be datetime, str, int, or float, got: {type(timestamp)}"
+        )
+
+
+def validate_timestamp_format(timestamp_str: str) -> bool:
+    """
+    Validate that a timestamp string matches the standard format.
+
+    Parameters
+    ----------
+    timestamp_str : str
+        Timestamp string to validate
+
+    Returns
+    -------
+    bool
+        True if string matches standard format
+    """
+    try:
+        datetime.strptime(timestamp_str, STANDARD_FORMAT)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
+def format_for_filename(timestamp: Union[datetime, str]) -> str:
+    """
+    Format timestamp for use in filenames (no spaces or colons).
+
+    Parameters
+    ----------
+    timestamp : datetime or str
+        Timestamp to format
+
+    Returns
+    -------
+    str
+        Filename-safe timestamp string (YYYYMMDD_HHMMSS)
+
+    Examples
+    --------
+    >>> from datetime import datetime
+    >>> dt = datetime(2010, 6, 18, 10, 15, 0)
+    >>> format_for_filename(dt)
+    '20100618_101500'
+    """
+    dt = to_datetime(timestamp)
+    return dt.strftime("%Y%m%d_%H%M%S")
+
+
+def format_for_display(timestamp: Union[datetime, str]) -> str:
+    """
+    Format timestamp for human-readable display.
+
+    Parameters
+    ----------
+    timestamp : datetime or str
+        Timestamp to format
+
+    Returns
+    -------
+    str
+        Human-readable timestamp string
+
+    Examples
+    --------
+    >>> from datetime import datetime
+    >>> dt = datetime(2010, 6, 18, 10, 15, 0)
+    >>> format_for_display(dt)
+    '2010-06-18 10:15:00'
+    """
+    dt = to_datetime(timestamp)
+    return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def parse_patient_recording_start_format(
+    patient_recording_start_str: str,
+) -> datetime:
+    """
+    Parse recording start time from CONFIG.PATIENTS.REC_START format.
+
+    Parameters
+    ----------
+    patient_recording_start_str : str
+        Recording start time string in format "DD/MM/YYYY, HH:MM:SS"
+
+    Returns
+    -------
+    datetime
+        Parsed datetime object
+
+    Examples
+    --------
+    >>> parse_patient_recording_start_format("10/06/2010, 07:40:34")
+    datetime.datetime(2010, 6, 10, 7, 40, 34)
+    """
+    REC_START_FORMAT = "%d/%m/%Y, %H:%M:%S"
+    return datetime.strptime(patient_recording_start_str, REC_START_FORMAT)
+
+
+def get_time_delta_seconds(
+    start: Union[datetime, str], end: Union[datetime, str]
+) -> float:
+    """
+    Calculate time difference in seconds between two timestamps.
+
+    Parameters
+    ----------
+    start : datetime or str
+        Start timestamp
+    end : datetime or str
+        End timestamp
+
+    Returns
+    -------
+    float
+        Time difference in seconds
+    """
+    start_dt = to_datetime(start)
+    end_dt = to_datetime(end)
+    delta = end_dt - start_dt
+    return delta.total_seconds()
+
+
+# EOF

scitex/db/_delete_duplicates.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-07-12 12:00:00 (ywatanabe)"
 # File: ./src/scitex/db/_delete_duplicates.py
 # ----------------------------------------
@@ -15,7 +14,8 @@ The actual implementation has been moved to _sqlite3._delete_duplicates
 as it is SQLite3-specific.
 """
 
-from scitex.errors import warn_deprecated
+from scitex.logging import warn_deprecated
+
 from ._sqlite3._delete_duplicates import delete_sqlite3_duplicates
 
 
@@ -28,8 +28,8 @@ def delete_duplicates(*args, **kwargs):
         Use scitex.db._sqlite3.delete_sqlite3_duplicates() instead.
     """
     warn_deprecated(
-        old_function="scitex.db.delete_duplicates",
-        new_function="scitex.db._sqlite3.delete_sqlite3_duplicates",
+        old_name="scitex.db.delete_duplicates",
+        new_name="scitex.db._sqlite3.delete_sqlite3_duplicates",
         version="3.0.0",
     )
     return delete_sqlite3_duplicates(*args, **kwargs)

scitex/db/_sqlite3/_delete_duplicates.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-07-16 14:00:04 (ywatanabe)"
 # File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/db/_sqlite3/_delete_duplicates.py
 # ----------------------------------------
@@ -177,7 +176,17 @@ def _delete_entry(
         cursor, duplicated_row, table_name, dry_run
     )
     if is_verified:
-        delete_query = select_query.replace("SELECT", "DELETE")
+        # Construct proper DELETE query (delete only one matching row)
+        columns = list(duplicated_row.index)
+        where_conditions = " AND ".join([f"{col} = ?" for col in columns])
+        delete_query = f"""
+            DELETE FROM {table_name}
+            WHERE rowid IN (
+                SELECT rowid FROM {table_name}
+                WHERE {where_conditions}
+                LIMIT 1
+            )
+        """
         if dry_run:
             print(f"[DRY RUN] Would delete entry:\n{duplicated_row}")
         else: