sequenzo 0.1.18__cp310-cp310-win_amd64.whl → 0.1.19__cp310-cp310-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/visualization/plot_transition_matrix.py

@@ -1,5 +1,5 @@
 """
-@Author  : Yuqi Liang 梁彧祺
+@Author  : Yuqi Liang 梁彧祺, Sebastian Daza
 @File    : plot_transition_matrix.py
 @Time    : 13/02/2025 12:39
 @Desc    :
@@ -32,12 +32,12 @@ def compute_transition_matrix(seqdata: SequenceData, with_missing: bool = False,
     # Process weights
     if isinstance(weights, str) and weights == "auto":
         weights = getattr(seqdata, "weights", None)
-    
+
     if weights is not None:
         weights = np.asarray(weights, dtype=float).reshape(-1)
         if len(weights) != len(seqdata.values):
             raise ValueError("Length of weights must equal number of sequences.")
-    
+
     num_states = len(seqdata.states)
     A = seqdata.to_dataframe().to_numpy()
     n, T = A.shape
@@ -52,19 +52,19 @@ def compute_transition_matrix(seqdata: SequenceData, with_missing: bool = False,
     nxt = A[:, 1:].flatten()
     w_pair = np.repeat(w, T-1)  # Each sequence weight replicated (T-1) times
 
-    # Filter valid transitions
-    valid = (current >= 0) & (current < num_states) & (nxt >= 0) & (nxt < num_states)
+    # Filter valid transitions (states are encoded as 1, 2, 3, ..., num_states)
+    valid = (current >= 1) & (current <= num_states) & (nxt >= 1) & (nxt <= num_states)
     current, nxt, w_pair = current[valid], nxt[valid], w_pair[valid]
 
     # Compute weighted transition counts
     # Create mapping from state codes to matrix indices
     state_codes = sorted(set(current) | set(nxt))
     code_to_idx = {code: idx for idx, code in enumerate(state_codes)}
-    
+
     # Use only the actual number of unique states for matrix size
     actual_num_states = len(state_codes)
     trans = np.zeros((actual_num_states, actual_num_states), dtype=float)
-    
+
     for c, n2, ww in zip(current, nxt, w_pair):
         trans[code_to_idx[int(c)], code_to_idx[int(n2)]] += ww
 
@@ -75,7 +75,7 @@ def compute_transition_matrix(seqdata: SequenceData, with_missing: bool = False,
 
     # Create a properly sized matrix with correct mapping to original states
     final_matrix = np.zeros((num_states, num_states), dtype=float)
-    
+
     # Map back to the original state positions
     for i, from_code in enumerate(state_codes):
         for j, to_code in enumerate(state_codes):
@@ -92,7 +92,7 @@ def print_transition_matrix(seqdata: SequenceData, transition_rates: np.ndarray)
     :param seqdata: SequenceData object containing state information
     :param transition_rates: numpy array containing transition rates
     """
-    state_labels = seqdata.states
+    state_labels = seqdata.labels
 
     # Calculate max width needed for state labels
     max_label_width = max(len(s) for s in state_labels) + 3  # +3 for arrow
@@ -127,45 +127,45 @@ def print_transition_matrix(seqdata: SequenceData, transition_rates: np.ndarray)
 
 def plot_transition_matrix(seqdata: SequenceData,
                            weights="auto",
-                           title: Optional[str] = None,
+                           title: str = "State Transition Rate Matrix",
                            fontsize: int = 12,
                            save_as: Optional[str] = None,
-                           dpi: int = 200) -> None:
+                           dpi: int = 200,
+                           format: str = "%.2f") -> None:
     """
     Plot state transition rate matrix as a heatmap.
 
     :param seqdata: SequenceData object containing sequence information
     :param weights: (np.ndarray or "auto") Weights for sequences. If "auto", uses seqdata.weights if available
     :param title: optional title for the plot
+    :param fontsize: base font size for labels
     :param save_as: optional file path to save the plot
     :param dpi: resolution of the saved plot
+    :param format: format string for annotations (default "%.2f")
     """
+
     # Compute transition matrix with weights
     transition_matrix = compute_transition_matrix(seqdata, weights=weights)
     transition_matrix = np.array(transition_matrix)
 
-    # Create upper triangle mask (show diagonal)
-    mask = np.triu(np.ones(transition_matrix.shape, dtype=bool), k=1)
-
     # Set figure size
     plt.figure(figsize=(12, 10))
 
     # Use fresh color scheme
     cmap = sns.color_palette("light:#5A9", as_cmap=True)
 
-    # Generate heatmap
+    # Generate heatmap using pre-formatted annotation strings
     ax = sns.heatmap(
         transition_matrix,
-        mask=mask,
-        annot=True,
-        fmt=".2f",
+        fmt=format,
         cmap=cmap,
         xticklabels=seqdata.labels,
         yticklabels=seqdata.labels,
         linewidths=0.5,
         linecolor="gray",
         cbar_kws={"shrink": 0.8},
-        square=True
+        square=True,
+        annot_kws={"fontsize": fontsize - 2}
     )
 
     # Show all the borderlines
@@ -175,7 +175,7 @@ def plot_transition_matrix(seqdata: SequenceData,
     # Adjust format
     if title:
         show_plot_title(plt.gca(), title, show=True, fontsize=fontsize+2, fontweight='bold', pad=20)
-    # plt.title("State Transition Rate Matrix", fontsize=14, fontweight='bold', pad=20)
+
     plt.xlabel("State at t + 1", fontsize=fontsize, labelpad=10)
     plt.ylabel("State at t", fontsize=fontsize, labelpad=10)
 
@@ -186,5 +186,4 @@ def plot_transition_matrix(seqdata: SequenceData,
     # Adjust layout
     plt.tight_layout()
 
-    save_and_show_results(save_as, dpi=200)
-
+    save_and_show_results(save_as, dpi=dpi)

{sequenzo-0.1.18.dist-info → sequenzo-0.1.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sequenzo
-Version: 0.1.18
+Version: 0.1.19
 Summary: A fast, scalable and intuitive Python package for social sequence analysis.
 Author-email: Yuqi Liang <yuqi.liang.1900@gmail.com>, Xinyi Li <1836724126@qq.com>, Jan Heinrich Ernst Meyerhoff-Liang <jan.meyerhoff1@gmail.com>
 License: BSD 3-Clause License
@@ -54,11 +54,15 @@ Requires-Dist: cython>=0.29.21
 Requires-Dist: scipy>=1.6.3
 Requires-Dist: scikit-learn>=0.24.2
 Requires-Dist: fastcluster>=1.2.6
+Requires-Dist: rpy2>=3.5.12; python_version >= "3.12"
+Requires-Dist: rpy2>=3.5.6; python_version == "3.11"
+Requires-Dist: rpy2>=3.5.6; python_version == "3.10"
+Requires-Dist: rpy2>=3.5.6; python_version == "3.9"
 Requires-Dist: joblib>=1.0.1
 Requires-Dist: docutils>=0.17
 Requires-Dist: tqdm<5.0.0,>=4.62.3
 Requires-Dist: missingno<0.6.0,>=0.5.2
-Requires-Dist: rpy2
+Requires-Dist: cffi>=1.15.0
 Provides-Extra: dev
 Requires-Dist: pytest>=6.2.5; extra == "dev"
 Requires-Dist: flake8>=3.9.2; extra == "dev"
@@ -97,6 +101,11 @@ Sequenzo outperforms traditional R-based tools in social sequence analysis, deli
 >  
 > 📖 Available in **English and Chinese**, our docs are written to be approachable, practical, and easy to follow.
 
+## ✨ Be part of the Sequenzo community
+Join our Discord channel to iscuss ideas, get help, and hear about upcoming Sequenzo versions, tutorials, and workshops first.
+
+➡️ https://discord.gg/3bMDKRHW
+
 ## Target Users
 
 Sequenzo is designed for:
@@ -172,6 +181,22 @@ If you have some issues with the installation, it might because you have both Py
 pip3 install sequenzo
 ```
 
+### Optional R Integration
+
+Sequenzo now checks the system environment variables before running ward.D hierarchical clustering.
+
+If R is missing, a relevant prompt will be displayed along with specific installation instructions. If `fastcluster` is missing, Sequenzo will automatically download `fastcluster`.
+
+Before automatically downloading `fastcluster`, Sequenzo checks whether R is available; if R is not installed, sequenzo will not automatically download fastcluster.
+
+Sequenzo supports advanced Ward clustering methods that require R integration. If you need to use the `ward_d` clustering method, install with R support:
+
+```
+pip install sequenzo[r]
+```
+
+This will install the optional `rpy2` dependency, which provides Python-R interoperability. Note that R must also be installed on your system for `rpy2` to work.
+
 For more information about the latest stable release and required dependencies, please refer to [PyPI](https://pypi.org/project/sequenzo/). 
 
 ## Documentation
@@ -209,7 +234,7 @@ Check out our [contribution guide]() for more details (work in progress).
 If you're contributing or debugging, use:
 
 ```bash
-pip install -r requirements-3.10.txt  # Or matching your Python version
+pip install -r requirements/requirements-3.10.txt  # Or matching your Python version
 ```
     
 For standard installation, use:
@@ -222,23 +247,31 @@ pip install .  # Uses pyproject.toml
 
 **Paper Authors**
 * [Yuqi Liang, University of Oxford](https://www.yuqi-liang.tech/)
-* [Xinyi Li, Heilongjiang University](https://github.com/Fantasy201)
+* [Xinyi Li, Northeastern University](https://github.com/Fantasy201)
 * [Jan Heinrich Ernst Meyerhoff-Liang, Institute for New Economic Thinking Oxford](https://www.inet.ox.ac.uk/people/jan-meyerhoff-liang)
 
 **Package Contributors**
-* [Liangxingyun He, Stockholm School of Economics (Sweden)](https://www.linkedin.com/in/liangxingyun-he-6aa128304/)
-* [Yukun Ming, Universidad Carlos III de Madrid (Spain)](www.linkedin.com/in/yukun)
-* [Ziting Yang, Rochester Wniversity (US)](www.linkedin.com/in/ziting-yang-7b33832bb)
+
+Coding contributors:
+* [Sebastian Daza](https://sdaza.com/)
+* [Cheng Deng](https://github.com/de-de-de-de-de)
+* [Liangxingyun He, Stockholm School of Economics, Sweden](https://www.linkedin.com/in/liangxingyun-he-6aa128304/)
+
+Documentation contributors:
+* [Liangxingyun He, Stockholm School of Economics, Sweden](https://www.linkedin.com/in/liangxingyun-he-6aa128304/)
+* [Yukun Ming, Universidad Carlos III de Madrid (Spain)](https://www.linkedin.com/in/yukun)
 * [Sizhu Qu, Northeastern University (US)](https://www.linkedin.com/in/sizhuq)
+* [Ziting Yang, Rochester Wniversity (US)](https://www.linkedin.com/in/ziting-yang-7b33832bb)
+
+Others
 * With special thanks to our initial testers (alphabetically ordered): [Joji Chia](https://sociology.illinois.edu/directory/profile/jbchia2), [Kass Gonzalez](https://www.linkedin.com/in/kass-gonzalez-72a778276/), [Sinyee Lu](https://sociology.illinois.edu/directory/profile/qianyil4), [Sohee Shin](https://sociology.illinois.edu/directory/profile/sohees2)
 * Website and related technical support: [Mactavish](https://github.com/mactavishz)
-* PAM clustering algorithm implementation: Cheng Deng
 * Sequence data sources compilation - History: Jingrui Chen
 * Visual design consultant: Changyu Yi
 
 **Acknowledgements**
 
-* Methodological advisor in sequence analysis: [Professor Tim Liao, University of Illinois Urbana-Champaign](https://sociology.illinois.edu/directory/profile/tfliao)
-* Yuqi's PhD advisor: [Professor Ridhi Kashyap, University of Oxford](https://www.nuffield.ox.ac.uk/people/profiles/ridhi-kashyap/)
+* Methodological advisor in sequence analysis: [Professor Tim Liao (University of Illinois Urbana-Champaign)](https://sociology.illinois.edu/directory/profile/tfliao)
+* Yuqi's PhD advisor [Professor Ridhi Kashyap (University of Oxford)](https://www.nuffield.ox.ac.uk/people/profiles/ridhi-kashyap/), and mentor [Charles Rahal (University of Oxford)](https://crahal.com/)
 * Yuqi's original programming mentor: [JiangHuShiNian](https://github.com/jianghushinian)