sequenzo 0.1.17__cp311-cp311-win_amd64.whl → 0.1.19__cp311-cp311-win_amd64.whl

sequenzo/multidomain/cat.py

@@ -412,7 +412,6 @@ def compute_cat_distance_matrix(channels: List[SequenceData],
             with contextlib.redirect_stdout(io.StringIO()):
                 newseqdata_seq = SequenceData(newseqdata_df,
                                               time=md_cnames,
-                                              time_type=channels[0].time_type,
                                               states=states_space,
                                               labels=md_labels,
                                               id_col=channels[0].id_col)
@@ -430,55 +429,3 @@ def compute_cat_distance_matrix(channels: List[SequenceData],
 
             diss_matrix = pd.DataFrame(diss_matrix, index=channels[0].ids, columns=channels[0].ids)
             return diss_matrix
-
-
-if __name__ == '__main__':
-    # from sequenzo import *
-    #
-    # # df = pd.read_csv("D:/college/research/QiQi/sequenzo/files/sampled_data_sets/broad_data/sampled_30000_data.csv")
-    # # df = pd.read_csv("D:/college/research/QiQi/sequenzo/files/orignal data/detailed_sequence_10_work_years_df.csv")
-    # # df = pd.read_csv("D:/college/research/QiQi/sequenzo/seqdef/sampled_data_1000.csv")
-    # df = pd.read_csv("D:/college/research/QiQi/sequenzo/files/sampled_data_sets/detailed_data/sampled_1000_data.csv")
-    #
-    # # df = pd.read_csv("D:/country_co2_emissions_missing.csv")
-    #
-    # time = list(df.columns)[4:]
-    # # time = list(df.columns)[1:]
-    #
-    # # states = ['Very Low', 'Low', 'Middle', 'High', 'Very High']
-    # states = ['data', 'data & intensive math', 'hardware', 'research', 'software', 'software & hardware', 'support & test']
-    # # states = ['Non-computing', 'Non-technical computing', 'Technical computing']
-    #
-    # sequence_data = SequenceData(df[['worker_id', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'C10']],
-    #                              time_type="age", time=time, id_col="worker_id", states=states)
-    # # sequence_data = SequenceData(df, time_type="age", time=time, id_col="country", states=states)
-    #
-    # sequence_data = [sequence_data, sequence_data]
-    #
-    # MD = seqMD(sequence_data, method="OM", sm=["TRATE"], indel="auto", what="diss", link="mean")
-    # print(MD)
-    #
-    # print("================")
-
-    from sequenzo import *
-
-    left_df = load_dataset('biofam_left_domain')
-    children_df = load_dataset('biofam_child_domain')
-    married_df = load_dataset('biofam_married_domain')
-
-    time_cols = [col for col in children_df.columns if col.startswith("age_")]
-
-    seq_left = SequenceData(data=left_df, time_type="age", time=time_cols, states=[0, 1],
-                            labels=["At home", "Left home"])
-    seq_child = SequenceData(data=children_df, time_type="age", time=time_cols, states=[0, 1],
-                             labels=["No child", "Child"])
-    seq_marr = SequenceData(data=married_df, time_type="age", time=time_cols, states=[0, 1],
-                            labels=["Not married", "Married"])
-
-    sequence_data = [seq_left, seq_child, seq_marr]
-
-    cat_distance_matrix = compute_cat_distance_matrix(sequence_data, method="OM", sm=["TRATE"], indel=[2, 1, 1], what="diss", link="sum")
-
-    print(cat_distance_matrix)
-
-    print("================")

sequenzo/multidomain/idcd.py

@@ -130,7 +130,6 @@ def create_idcd_sequence_from_csvs(
 
     return SequenceData(
         data=combined_df,
-        time_type=time_type,
         time=time_cols,
         states=observed_states.index.tolist(),
         labels=pretty_labels,

sequenzo/openmp_setup.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+@Author  : Yuqi Liang 梁彧祺
+@File    : openmp_setup.py
+@Time    : 07/10/2025 10:42
+@Desc    : 
+
+OpenMP Setup for Apple Silicon Macs
+
+This module provides automatic OpenMP dependency management for Apple Silicon Macs.
+It ensures that libomp is available for parallel computation without requiring
+manual user intervention.
+"""
+
+import sys
+import os
+import subprocess
+import platform
+import ctypes
+from pathlib import Path
+
+
+def check_libomp_availability():
+    """
+    Check if libomp is available on the system.
+    
+    Returns:
+        bool: True if libomp is available, False otherwise
+    """
+    try:
+        # Try to load libomp directly
+        ctypes.CDLL('libomp.dylib')
+        return True
+    except OSError:
+        pass
+    
+    # Try common Homebrew paths
+    homebrew_paths = [
+        '/opt/homebrew/lib/libomp.dylib',  # Apple Silicon
+        '/usr/local/lib/libomp.dylib',     # Intel Mac
+    ]
+    
+    for path in homebrew_paths:
+        if os.path.exists(path):
+            try:
+                ctypes.CDLL(path)
+                return True
+            except OSError:
+                continue
+    
+    return False
+
+
+def check_homebrew_available():
+    """
+    Check if Homebrew is available on the system.
+    
+    Returns:
+        bool: True if Homebrew is available, False otherwise
+    """
+    try:
+        subprocess.run(['brew', '--version'], 
+                      stdout=subprocess.DEVNULL, 
+                      stderr=subprocess.DEVNULL, 
+                      check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+def install_libomp_via_homebrew():
+    """
+    Install libomp via Homebrew.
+    
+    Returns:
+        bool: True if installation successful, False otherwise
+    """
+    try:
+        print("🔧 Installing libomp via Homebrew...")
+        result = subprocess.run(['brew', 'install', 'libomp'], 
+                              check=True, 
+                              stdout=subprocess.PIPE, 
+                              stderr=subprocess.PIPE)
+        print("[>] libomp installed successfully!")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"[>] libomp installation failed: {e}")
+        return False
+    except Exception as e:
+        print(f"[>] Error during installation: {e}")
+        return False
+
+
+def setup_openmp_environment():
+    """
+    Set up OpenMP environment variables for Apple Silicon.
+    
+    Returns:
+        bool: True if setup successful, False otherwise
+    """
+    try:
+        # Get Homebrew prefix
+        result = subprocess.run(['brew', '--prefix'], 
+                              capture_output=True, text=True, check=True)
+        homebrew_prefix = result.stdout.strip()
+        
+        # Set environment variables
+        lib_path = f"{homebrew_prefix}/lib"
+        include_path = f"{homebrew_prefix}/include"
+        
+        os.environ['DYLD_LIBRARY_PATH'] = f"{lib_path}:{os.environ.get('DYLD_LIBRARY_PATH', '')}"
+        os.environ['LDFLAGS'] = f"-L{lib_path} {os.environ.get('LDFLAGS', '')}"
+        os.environ['CPPFLAGS'] = f"-I{include_path} {os.environ.get('CPPFLAGS', '')}"
+        
+        print(f"[>] OpenMP environment variables set")
+        print(f"   - Library path: {lib_path}")
+        print(f"   - Include path: {include_path}")
+        return True
+        
+    except Exception as e:
+        print(f"[>] Failed to set environment variables: {e}")
+        return False
+
+
+def ensure_openmp_support():
+    """
+    Ensure OpenMP support is available on Apple Silicon Macs.
+    This function handles the complete setup process.
+    
+    Returns:
+        bool: True if OpenMP is available, False otherwise
+    """
+    # Only run on macOS
+    if sys.platform != 'darwin':
+        return True
+    
+    # Only run on Apple Silicon
+    if platform.machine() != 'arm64':
+        return True
+    
+    # Check if we're in a conda environment (don't interfere)
+    if os.environ.get('CONDA_DEFAULT_ENV'):
+        print("[>] Detected Conda environment, skipping OpenMP auto-setup")
+        return True
+    
+    print("[>] Detected Apple Silicon Mac, checking OpenMP support...")
+    
+    # Check if libomp is already available
+    if check_libomp_availability():
+        print("[>] OpenMP support is available")
+        return True
+    
+    # Check if Homebrew is available
+    if not check_homebrew_available():
+        print("""
+[>] OpenMP Dependency Detection
+
+On Apple Silicon Mac, Sequenzo requires OpenMP support for parallel computation.
+
+Please run the following command to install OpenMP support:
+    brew install libomp
+
+If you don't have Homebrew installed, please visit https://brew.sh to install Homebrew first.
+        """)
+        return False
+    
+    # Check if libomp is already installed via Homebrew
+    try:
+        subprocess.run(['brew', 'list', 'libomp'], 
+                      stdout=subprocess.DEVNULL, 
+                      stderr=subprocess.DEVNULL, 
+                      check=True)
+        print("[>] libomp is already installed via Homebrew")
+        
+        # Set up environment variables
+        setup_openmp_environment()
+        return True
+    except subprocess.CalledProcessError:
+        pass  # libomp not installed, continue with installation
+    
+    # Attempt to install libomp automatically
+    if install_libomp_via_homebrew():
+        # Set up environment variables after installation
+        setup_openmp_environment()
+        return True
+    else:
+        print("""
+[>] Automatic OpenMP installation failed
+
+Please manually run the following command:
+    brew install libomp
+
+After installation, please restart Python or re-import sequenzo.
+        """)
+        return False
+
+
+def get_openmp_status():
+    """
+    Get the current OpenMP status and provide helpful information.
+    
+    Returns:
+        dict: Status information about OpenMP support
+    """
+    status = {
+        'platform': sys.platform,
+        'architecture': platform.machine(),
+        'is_apple_silicon': sys.platform == 'darwin' and platform.machine() == 'arm64',
+        'libomp_available': check_libomp_availability(),
+        'homebrew_available': check_homebrew_available(),
+        'conda_environment': bool(os.environ.get('CONDA_DEFAULT_ENV')),
+    }
+    
+    return status
+
+
+if __name__ == "__main__":
+    # Run the setup when called directly
+    success = ensure_openmp_support()
+    if success:
+        print("[>] OpenMP support is ready!")
+    else:
+        print("[>] OpenMP support unavailable, will use serial computation")
+    
+    # Print status information
+    status = get_openmp_status()
+    print(f"\n[>] System Status:")
+    print(f"   - Platform: {status['platform']}")
+    print(f"   - Architecture: {status['architecture']}")
+    print(f"   - Apple Silicon: {status['is_apple_silicon']}")
+    print(f"   - libomp available: {status['libomp_available']}")
+    print(f"   - Homebrew available: {status['homebrew_available']}")
+    print(f"   - Conda environment: {status['conda_environment']}")

sequenzo/sequence_characteristics/__init__.py

@@ -18,6 +18,8 @@ from .variance_of_spell_durations import get_spell_duration_variance
 
 from .turbulence import get_turbulence
 
+from .complexity_index import get_complexity_index
+
 from .plot_characteristics import plot_longitudinal_characteristics, plot_cross_sectional_characteristics
 
 __all__ = [
@@ -25,6 +27,8 @@ __all__ = [
     "get_subsequences_all_sequences",
     "get_number_of_transitions",
 
+    "get_complexity_index",
+
     "get_state_freq_and_entropy_per_seq",
     "get_within_sequence_entropy",
     "get_cross_sectional_entropy",

sequenzo/sequence_characteristics/complexity_index.py

@@ -18,72 +18,32 @@ from .within_sequence_entropy import get_within_sequence_entropy
 
 def get_complexity_index(seqdata, silent=True):
     if not isinstance(seqdata, SequenceData):
-        raise ValueError(" [!] data is NOT a sequence object, see SequenceData function to create one.")
+        raise ValueError("[!] data is NOT a sequence object, see SequenceData function to create one.")
 
     if not silent:
-        print(f"  - computing complexity index for {seqdata.seqdata.shape[0]} sequences ...")
+        print(f"[>] Computing complexity index for {seqdata.seqdata.shape[0]} sequences ...")
 
-    trans = get_number_of_transitions(seqdata=seqdata, norm=True)
+    trans = get_number_of_transitions(seqdata=seqdata, norm=True).iloc[:, 1]
+    trans.index = seqdata.seqdata.index
 
     with open(os.devnull, 'w') as fnull:
         with redirect_stdout(fnull):
-            ient = get_within_sequence_entropy(seqdata=seqdata, norm=True)
+            ient = get_within_sequence_entropy(seqdata=seqdata, norm=True).iloc[:, 1]
+            ient.index = seqdata.seqdata.index
 
-    complxity = np.sqrt(trans.iloc[:, 0] * ient)
-    complxity.columns = ['ComplexityIndex']
+    complxity = np.sqrt(trans * ient)
+    complxity = pd.DataFrame(complxity, index=seqdata.seqdata.index, columns=['Complexity Index'])
+    complxity = complxity.reset_index().rename(columns={'index': 'ID'})
 
     return complxity
 
+if __name__ == '__main__':
+    from sequenzo import *
 
-if __name__ == "__main__":
-    # ===============================
-    #             Sohee
-    # ===============================
-    df = pd.read_csv('D:/college/research/QiQi/sequenzo/data_and_output/orignal data/sohee/sequence_data.csv')
-    time_list = list(df.columns)[1:133]
-    states = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
-    # states = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
-    labels = ['FT+WC', 'FT+BC', 'PT+WC', 'PT+BC', 'U', 'OLF']
-    sequence_data = SequenceData(df, time=time_list, states=states, labels=labels, id_col="PID")
-    res = get_complexity_index(sequence_data)
-
-    # ===============================
-    #             kass
-    # ===============================
-    # df = pd.read_csv('D:/college/research/QiQi/sequenzo/files/orignal data/kass/wide_civil_final_df.csv')
-    # time_list = list(df.columns)[1:]
-    # states = ['Extensive Warfare', 'Limited Violence', 'No Violence', 'Pervasive Warfare', 'Prolonged Warfare',
-    #           'Serious Violence', 'Serious Warfare', 'Sporadic Violence', 'Technological Warfare', 'Total Warfare']
-    # sequence_data = SequenceData(df, time=time_list, states=states, id_col="COUNTRY")
-    # res = seqici(sequence_data)
-
-    # ===============================
-    #             CO2
-    # ===============================
-    # df = pd.read_csv("D:/country_co2_emissions_missing.csv")
-    # _time = list(df.columns)[1:]
-    # states = ['Very Low', 'Low', 'Middle', 'High', 'Very High']
-    # sequence_data = SequenceData(df, time=_time, id_col="country", states=states)
-    # res = seqici(sequence_data)
+    df = load_dataset("country_co2_emissions")
+    _time = list(df.columns)[1:]
+    states = ['Very Low', 'Low', 'Middle', 'High', 'Very High']
+    sequence_data = SequenceData(df, time=_time, id_col="country", states=states)
 
-    # ===============================
-    #            detailed
-    # ===============================
-    # df = pd.read_csv("D:/college/research/QiQi/sequenzo/data_and_output/sampled_data_sets/detailed_data/sampled_1000_data.csv")
-    # _time = list(df.columns)[4:]
-    # states = ['data', 'data & intensive math', 'hardware', 'research', 'software', 'software & hardware', 'support & test']
-    # sequence_data = SequenceData(df[['worker_id', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'C10']],
-    #                              time=_time, id_col="worker_id", states=states)
-    # res = seqici(sequence_data)
-
-    # ===============================
-    #             broad
-    # ===============================
-    # df = pd.read_csv("D:/college/research/QiQi/sequenzo/data_and_output/sampled_data_sets/broad_data/sampled_1000_data.csv")
-    # _time = list(df.columns)[4:]
-    # states = ['Non-computing', 'Non-technical computing', 'Technical computing']
-    # sequence_data = SequenceData(df[['worker_id', 'C1', 'C2', 'C3', 'C4', 'C5']],
-    #                              time=_time, id_col="worker_id", states=states)
-    # res = seqici(sequence_data)
-
-    print(res)
+    res = get_complexity_index(sequence_data)
+    res