{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "425fa93d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import os\n",
    "sys.path.append(os.path.abspath(os.path.join(os.getcwd(), '../..')))\n",
    "\n",
    "# Path Configuration\n",
    "from tools.preprocess import *\n",
    "\n",
    "# Processing context\n",
    "trait = \"Multiple_sclerosis\"\n",
    "cohort = \"GSE131282\"\n",
    "\n",
    "# Input paths\n",
    "in_trait_dir = \"../../input/GEO/Multiple_sclerosis\"\n",
    "in_cohort_dir = \"../../input/GEO/Multiple_sclerosis/GSE131282\"\n",
    "\n",
    "# Output paths\n",
    "out_data_file = \"../../output/preprocess/Multiple_sclerosis/GSE131282.csv\"\n",
    "out_gene_data_file = \"../../output/preprocess/Multiple_sclerosis/gene_data/GSE131282.csv\"\n",
    "out_clinical_data_file = \"../../output/preprocess/Multiple_sclerosis/clinical_data/GSE131282.csv\"\n",
    "json_path = \"../../output/preprocess/Multiple_sclerosis/cohort_info.json\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a8c4116",
   "metadata": {},
   "source": [
    "### Step 1: Initial Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42d27a5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tools.preprocess import *\n",
    "# 1. Identify the paths to the SOFT file and the matrix file\n",
    "soft_file, matrix_file = geo_get_relevant_filepaths(in_cohort_dir)\n",
    "\n",
    "# 2. Read the matrix file to obtain background information and sample characteristics data\n",
    "background_prefixes = ['!Series_title', '!Series_summary', '!Series_overall_design']\n",
    "clinical_prefixes = ['!Sample_geo_accession', '!Sample_characteristics_ch1']\n",
    "background_info, clinical_data = get_background_and_clinical_data(matrix_file, background_prefixes, clinical_prefixes)\n",
    "\n",
    "# 3. Obtain the sample characteristics dictionary from the clinical dataframe\n",
    "sample_characteristics_dict = get_unique_values_by_row(clinical_data)\n",
    "\n",
    "# 4. Explicitly print out all the background information and the sample characteristics dictionary\n",
    "print(\"Background Information:\")\n",
    "print(background_info)\n",
    "print(\"Sample Characteristics Dictionary:\")\n",
    "print(sample_characteristics_dict)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94e3e9e5",
   "metadata": {},
   "source": [
    "### Step 2: Dataset Analysis and Clinical Feature Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b01d0c62",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Analyzing the dataset based on the background information and sample characteristics\n",
    "\n",
    "# 1. Gene Expression Data Availability\n",
    "# Based on the title and information, this appears to be gene expression data from brain tissue\n",
    "# of multiple sclerosis patients and controls, not just miRNA or methylation\n",
    "is_gene_available = True\n",
    "\n",
    "# 2. Variable Availability and Data Type Conversion\n",
    "# 2.1 Data Availability\n",
    "# The trait (Multiple Sclerosis) information can be found in key 6 'tissue' or key 4 'ms type'\n",
    "# Using key 6 as it distinguishes between Grey Matter Lesion (MS) and Grey Matter (likely controls)\n",
    "trait_row = 6\n",
    "\n",
    "# Age information is in key 2 'age at death'\n",
    "age_row = 2\n",
    "\n",
    "# Gender information is in key 1 'Sex'\n",
    "gender_row = 1\n",
    "\n",
    "# 2.2 Data Type Conversion Functions\n",
    "def convert_trait(value):\n",
    "    \"\"\"Convert tissue type to binary MS status (1 for MS, 0 for control)\"\"\"\n",
    "    if value is None:\n",
    "        return None\n",
    "    \n",
    "    # Extract value after colon if present\n",
    "    if ':' in value:\n",
    "        value = value.split(':', 1)[1].strip()\n",
    "    \n",
    "    # Grey Matter Lesion indicates MS, Grey Matter indicates control\n",
    "    if value == 'Grey Matter Lesion':\n",
    "        return 1  # MS\n",
    "    elif value == 'Grey Matter':\n",
    "        return 0  # Control\n",
    "    else:\n",
    "        return None  # Unknown or not relevant\n",
    "\n",
    "def convert_age(value):\n",
    "    \"\"\"Convert age at death to continuous value\"\"\"\n",
    "    if value is None:\n",
    "        return None\n",
    "    \n",
    "    # Extract value after colon if present\n",
    "    if ':' in value:\n",
    "        value = value.split(':', 1)[1].strip()\n",
    "    \n",
    "    # Convert to integer\n",
    "    try:\n",
    "        return int(value)\n",
    "    except (ValueError, TypeError):\n",
    "        return None\n",
    "\n",
    "def convert_gender(value):\n",
    "    \"\"\"Convert sex to binary (0 for female, 1 for male)\"\"\"\n",
    "    if value is None:\n",
    "        return None\n",
    "    \n",
    "    # Extract value after colon if present\n",
    "    if ':' in value:\n",
    "        value = value.split(':', 1)[1].strip()\n",
    "    \n",
    "    # Convert to binary\n",
    "    if value.upper() == 'F':\n",
    "        return 0  # Female\n",
    "    elif value.upper() == 'M':\n",
    "        return 1  # Male\n",
    "    else:\n",
    "        return None  # Unknown\n",
    "\n",
    "# 3. Save Metadata - Initial filtering\n",
    "is_trait_available = trait_row is not None\n",
    "validate_and_save_cohort_info(\n",
    "    is_final=False, \n",
    "    cohort=cohort, \n",
    "    info_path=json_path, \n",
    "    is_gene_available=is_gene_available, \n",
    "    is_trait_available=is_trait_available\n",
    ")\n",
    "\n",
    "# 4. Clinical Feature Extraction\n",
    "# We need to create a clinical data DataFrame from the sample characteristics\n",
    "if trait_row is not None:\n",
    "    # Create a DataFrame from the sample characteristics dictionary\n",
    "    sample_characteristics = {\n",
    "        0: ['patient id: M02', 'patient id: M60', 'patient id: M44', 'patient id: M13', 'patient id: M53', 'patient id: M14', 'patient id: M56', 'patient id: M46', 'patient id: M61', 'patient id: M42', 'patient id: M28', 'patient id: M23', 'patient id: M52', 'patient id: M12', 'patient id: M32', 'patient id: M06', 'patient id: M01', 'patient id: M36', 'patient id: M59', 'patient id: M34', 'patient id: M26', 'patient id: M03', 'patient id: M54', 'patient id: M30', 'patient id: M57', 'patient id: M43', 'patient id: M48', 'patient id: M51', 'patient id: M10', 'patient id: M24'],\n",
    "        1: ['Sex: F', 'Sex: M'],\n",
    "        2: ['age at death: 58', 'age at death: 59', 'age at death: 80', 'age at death: 63', 'age at death: 47', 'age at death: 78', 'age at death: 88', 'age at death: 45', 'age at death: 61', 'age at death: 50', 'age at death: 54', 'age at death: 69', 'age at death: 39', 'age at death: 56', 'age at death: 44', 'age at death: 42', 'age at death: 92', 'age at death: 71', 'age at death: 77', 'age at death: 34', 'age at death: 49', 'age at death: 70', 'age at death: 35', 'age at death: 84', 'age at death: 75', 'age at death: 38', 'age at death: 64', 'age at death: 95', 'age at death: 60', 'age at death: 51'],\n",
    "        6: ['tissue: Grey Matter Lesion', 'tissue: Grey Matter', 'disease duration: 21', 'disease duration: 54', 'disease duration: 31', 'disease duration: ?', 'disease duration: 36', 'disease duration: 34', 'disease duration: 17', 'disease duration: 4', 'disease duration: 42', 'disease duration: 47', 'disease duration: 16', 'disease duration: 38', 'disease duration: 30', 'disease duration: 26', 'disease duration: 33', 'disease duration: 27', 'disease duration: 41', 'disease duration: 22', 'disease duration: 6', 'disease duration: 18']\n",
    "    }\n",
    "    \n",
    "    # Convert to DataFrame with column names matching the row indices\n",
    "    clinical_data = pd.DataFrame(sample_characteristics)\n",
    "    \n",
    "    # Extract clinical features\n",
    "    selected_clinical = geo_select_clinical_features(\n",
    "        clinical_df=clinical_data,\n",
    "        trait=trait,\n",
    "        trait_row=trait_row,\n",
    "        convert_trait=convert_trait,\n",
    "        age_row=age_row,\n",
    "        convert_age=convert_age,\n",
    "        gender_row=gender_row,\n",
    "        convert_gender=convert_gender\n",
    "    )\n",
    "    \n",
    "    # Preview the extracted clinical data\n",
    "    preview = preview_df(selected_clinical)\n",
    "    print(\"Preview of extracted clinical data:\")\n",
    "    print(preview)\n",
    "    \n",
    "    # Save clinical data to CSV\n",
    "    os.makedirs(os.path.dirname(out_clinical_data_file), exist_ok=True)\n",
    "    selected_clinical.to_csv(out_clinical_data_file)\n",
    "    print(f\"Clinical data saved to {out_clinical_data_file}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5b4b4ac",
   "metadata": {},
   "source": [
    "### Step 3: Dataset Analysis and Clinical Feature Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13537375",
   "metadata": {},
   "outputs": [],
   "source": [
    "I'll implement a properly formatted solution for this step that explores the dataset and extracts clinical features appropriately.\n",
    "\n",
    "```python\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import json\n",
    "import os\n",
    "import re\n",
    "\n",
    "# First, let's explore the directory contents to understand what data is available\n",
    "print(f\"Checking contents of: {in_cohort_dir}\")\n",
    "if os.path.exists(in_cohort_dir):\n",
    "    files = os.listdir(in_cohort_dir)\n",
    "    print(f\"Available files: {files}\")\n",
    "else:\n",
    "    print(f\"Directory {in_cohort_dir} does not exist\")\n",
    "\n",
    "# Try loading the matrix file, which typically contains both gene expression and clinical data\n",
    "matrix_path = os.path.join(in_cohort_dir, \"matrix.tsv\")\n",
    "if os.path.exists(matrix_path):\n",
    "    print(f\"Found matrix file at: {matrix_path}\")\n",
    "    matrix_df = pd.read_csv(matrix_path, sep=\"\\t\", index_col=0)\n",
    "    print(f\"Matrix shape: {matrix_df.shape}\")\n",
    "    print(\"First few rows and columns of the matrix:\")\n",
    "    print(matrix_df.iloc[:5, :5])\n",
    "\n",
    "    # Check if the first row contains clinical information\n",
    "    if not pd.api.types.is_numeric_dtype(matrix_df.iloc[0]):\n",
    "        # The first rows might contain clinical information\n",
    "        # Extract these rows as clinical data\n",
    "        clinical_data = matrix_df.iloc[:20].T  # Transpose to get samples as rows\n",
    "        print(\"Potential clinical data (first 20 rows):\")\n",
    "        print(clinical_data.head())\n",
    "        \n",
    "        # Rest of the matrix is likely gene expression data\n",
    "        gene_data = matrix_df.iloc[20:].T  # Transpose to get samples as rows\n",
    "        print(f\"Potential gene expression data shape: {gene_data.shape}\")\n",
    "    else:\n",
    "        # The matrix might be pure gene expression without clinical data\n",
    "        print(\"The matrix appears to contain only gene expression data.\")\n",
    "        gene_data = matrix_df.T  # Transpose to get samples as rows\n",
    "        clinical_data = None\n",
    "        \n",
    "else:\n",
    "    print(f\"Matrix file not found at: {matrix_path}\")\n",
    "    # Try alternative formats\n",
    "    series_matrix_path = os.path.join(in_cohort_dir, \"series_matrix.txt\")\n",
    "    if os.path.exists(series_matrix_path):\n",
    "        print(f\"Found series matrix file at: {series_matrix_path}\")\n",
    "        # Series matrix files typically have a specific format with !Series and !Sample lines\n",
    "        with open(series_matrix_path, 'r') as f:\n",
    "            lines = f.readlines()\n",
    "            \n",
    "        # Extract clinical information from series matrix\n",
    "        sample_char_dict = {}\n",
    "        sample_index = None\n",
    "        current_feature_idx = 0\n",
    "        \n",
    "        for i, line in enumerate(lines):\n",
    "            if line.startswith('!Sample_geo_accession'):\n",
    "                sample_index = i\n",
    "                headers = line.strip().split('\\t')[1:]\n",
    "            elif sample_index is not None and i > sample_index and line.startswith('!Sample_'):\n",
    "                feature_name = line.split('\\t')[0].replace('!Sample_', '')\n",
    "                values = line.strip().split('\\t')[1:]\n",
    "                sample_char_dict[str(current_feature_idx)] = values\n",
    "                current_feature_idx += 1\n",
    "                \n",
    "        # Convert to DataFrame for easier processing\n",
    "        if sample_index is not None:\n",
    "            clinical_data = pd.DataFrame(sample_char_dict)\n",
    "            clinical_data.index = headers\n",
    "            print(\"Clinical data extracted from series matrix:\")\n",
    "            print(clinical_data.head())\n",
    "        else:\n",
    "            clinical_data = None\n",
    "            print(\"No clinical data found in series matrix.\")\n",
    "    else:\n",
    "        print(f\"Series matrix file not found at: {series_matrix_path}\")\n",
    "        clinical_data = None\n",
    "\n",
    "# 1. Gene Expression Data Availability\n",
    "# Check if gene expression data is likely available based on files or matrix content\n",
    "is_gene_available = False\n",
    "if 'gene_data' in locals() and gene_data is not None and gene_data.shape[1] > 0:\n",
    "    is_gene_available = True\n",
    "    print(f\"Gene expression data appears to be available (shape: {gene_data.shape})\")\n",
    "else:\n",
    "    # Look for other indicators of gene expression data\n",
    "    if 'files' in locals():\n",
    "        for file in files:\n",
    "            if any(term in file.lower() for term in ['gene', 'expr', 'matrix', 'platform']):\n",
    "                is_gene_available = True\n",
    "                print(f\"Gene expression data likely available based on file: {file}\")\n",
    "                break\n",
    "\n",
    "# 2. Variable Availability and Data Type Conversion\n",
    "# Initialize variables\n",
    "trait_row = None\n",
    "age_row = None\n",
    "gender_row = None\n",
    "\n",
    "# Function to explore unique values in clinical data\n",
    "def explore_clinical_data(clinical_df):\n",
    "    if clinical_df is None:\n",
    "        return {}\n",
    "    \n",
    "    feature_dict = {}\n",
    "    for col in clinical_df.columns:\n",
    "        unique_values = clinical_df[col].unique()\n",
    "        if len(unique_values) <= 10:  # Only show if reasonable number of unique values\n",
    "            feature_dict[col] = list(unique_values)\n",
    "        else:\n",
    "            feature_dict[col] = f\"{len(unique_values)} unique values\"\n",
    "    return feature_dict\n",
    "\n",
    "if clinical_data is not None:\n",
    "    clinical_features = explore_clinical_data(clinical_data)\n",
    "    print(\"\\nClinical features available:\")\n",
    "    for col, values in clinical_features.items():\n",
    "        print(f\"Column {col}: {values}\")\n",
    "\n",
    "    # Analysis for trait (Multiple sclerosis)\n",
    "    for col in clinical_data.columns:\n",
    "        values = clinical_data[col].astype(str).str.lower()\n",
    "        if any(term in ' '.join(values) for term in ['ms', 'sclerosis', 'control', 'disease', 'diagnosis', 'patient']):\n",
    "            unique_vals = clinical_data[col].unique()\n",
    "            if len(unique_vals) > 1:  # Not a constant feature\n",
    "                trait_row = int(col)\n",
    "                print(f\"\\nTrait data found in column {trait_row}: {list(unique_vals)}\")\n",
    "                break\n",
    "\n",
    "    # Analysis for age\n",
    "    for col in clinical_data.columns:\n",
    "        values = clinical_data[col].astype(str).str.lower()\n",
    "        if any(term in ' '.join(values) for term in ['age', 'years', 'yr']):\n",
    "            unique_vals = clinical_data[col].unique()\n",
    "            if len(unique_vals) > 1:  # Not a constant feature\n",
    "                age_row = int(col)\n",
    "                print(f\"\\nAge data found in column {age_row}: {list(unique_vals)[:5]}\")\n",
    "                break\n",
    "\n",
    "    # Analysis for gender\n",
    "    for col in clinical_data.columns:\n",
    "        values = clinical_data[col].astype(str).str.lower()\n",
    "        if any(term in ' '.join(values) for term in ['gender', 'sex', 'male', 'female']):\n",
    "            unique_vals = clinical_data[col].unique()\n",
    "            if len(unique_vals) > 1:  # Not a constant feature\n",
    "                gender_row = int(col)\n",
    "                print(f\"\\nGender data found in column {gender_row}: {list(unique_vals)}\")\n",
    "                break\n",
    "\n",
    "# Define conversion functions\n",
    "def convert_trait(value):\n",
    "    if value is None:\n",
    "        return None\n",
    "    \n",
    "    value_str = str(value).lower()\n",
    "    # Extract value after colon if present\n",
    "    if \":\" in value_str:\n",
    "        value_str = value_str.split(\":\", 1)[1].strip()\n",
    "    \n",
    "    # Convert to binary: 1 for MS, 0 for Control\n",
    "    if any(kw in value_str for kw in [\"ms\", \"multiple sclerosis\", \"patient\", \"case\", \"affected\"]):\n",
    "        return 1\n",
    "    elif any(kw in value_str for kw in [\"control\", \"healthy\", \"normal\", \"hc\", \"unaffected\"]):\n",
    "        return 0\n",
    "    return None\n",
    "\n",
    "def convert_age(value):\n",
    "    if value is None:\n",
    "        return None\n",
    "    \n",
    "    value_str = str(value)\n",
    "    # Extract value after colon if present\n",
    "    if \":\" in value_str:\n",
    "        value_str = value_str.split(\":\", 1)[1].strip()\n",
    "    \n",
    "    #\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce22597e",
   "metadata": {},
   "source": [
    "### Step 4: Gene Data Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a89e6ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Extract the gene expression data from the matrix file\n",
    "gene_data = get_genetic_data(matrix_file)\n",
    "\n",
    "# 2. Print the first 20 row IDs (gene or probe identifiers)\n",
    "print(\"\\nFirst 20 gene/probe identifiers:\")\n",
    "print(gene_data.index[:20])\n",
    "\n",
    "# 3. Print the dimensions of the gene expression data\n",
    "print(f\"\\nGene data dimensions: {gene_data.shape[0]} genes × {gene_data.shape[1]} samples\")\n",
    "\n",
    "# Note: we keep is_gene_available as True since we successfully extracted gene expression data\n",
    "is_gene_available = True\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4800b01d",
   "metadata": {},
   "source": [
    "### Step 5: Gene Identifier Review"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40562249",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Looking at the gene identifiers, I can see they are not standard human gene symbols, but rather Illumina array probe IDs\n",
    "# (identifiers starting with ILMN_). These are specific to Illumina microarray platforms and need to be mapped to \n",
    "# actual human gene symbols for better biological interpretation.\n",
    "\n",
    "# Illumina probe IDs like ILMN_1343048 are specific identifiers for probes on Illumina microarray platforms\n",
    "# They need to be mapped to official gene symbols or Entrez Gene IDs for cross-platform comparability\n",
    "\n",
    "requires_gene_mapping = True\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1084f78c",
   "metadata": {},
   "source": [
    "### Step 6: Gene Annotation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "283b55a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. First get the file paths using geo_get_relevant_filepaths function\n",
    "soft_file, matrix_file = geo_get_relevant_filepaths(in_cohort_dir)\n",
    "\n",
    "# 2. Use the 'get_gene_annotation' function from the library to get gene annotation data from the SOFT file.\n",
    "gene_annotation = get_gene_annotation(soft_file)\n",
    "\n",
    "# 3. Use the 'preview_df' function from the library to preview the data and print out the results.\n",
    "print(\"Gene annotation preview:\")\n",
    "print(preview_df(gene_annotation))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b886570",
   "metadata": {},
   "source": [
    "### Step 7: Gene Identifier Mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70a99f37",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Identify which columns in gene_annotation contain probe IDs and gene symbols\n",
    "# From the preview, we can see that 'ID' column contains probe IDs (ILMN_*) matching our expression data\n",
    "# and 'Symbol' column contains gene symbols\n",
    "prob_col = 'ID'  # Column with probe IDs\n",
    "gene_col = 'Symbol'  # Column with gene symbols\n",
    "\n",
    "# 2. Get a gene mapping dataframe from the gene annotation data\n",
    "mapping_df = get_gene_mapping(gene_annotation, prob_col, gene_col)\n",
    "print(f\"Gene mapping dataframe shape: {mapping_df.shape}\")\n",
    "print(\"First few rows of mapping dataframe:\")\n",
    "print(mapping_df.head())\n",
    "\n",
    "# 3. Apply gene mapping to convert probe-level measurements to gene expression data\n",
    "# This will handle the many-to-many relationship between probes and genes as specified\n",
    "gene_data = apply_gene_mapping(gene_data, mapping_df)\n",
    "print(f\"Converted gene expression data shape: {gene_data.shape}\")\n",
    "print(\"First few gene symbols after mapping:\")\n",
    "print(gene_data.index[:10])\n",
    "\n",
    "# Normalize gene symbols to handle synonyms and aggregate rows with the same symbol\n",
    "gene_data = normalize_gene_symbols_in_index(gene_data)\n",
    "print(f\"After normalization, gene expression data shape: {gene_data.shape}\")\n",
    "print(\"First few normalized gene symbols:\")\n",
    "print(gene_data.index[:10])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4d2a695",
   "metadata": {},
   "source": [
    "### Step 8: Data Normalization and Linking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56a6a2f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Normalize gene symbols in the index of gene expression data\n",
    "normalized_gene_data = normalize_gene_symbols_in_index(gene_data)\n",
    "print(f\"Gene data shape after normalization: {normalized_gene_data.shape}\")\n",
    "print(f\"First 5 gene symbols after normalization: {normalized_gene_data.index[:5]}\")\n",
    "\n",
    "# Save the normalized gene data\n",
    "os.makedirs(os.path.dirname(out_gene_data_file), exist_ok=True)\n",
    "normalized_gene_data.to_csv(out_gene_data_file)\n",
    "print(f\"Normalized gene data saved to {out_gene_data_file}\")\n",
    "\n",
    "# 2. Check if clinical data was properly loaded\n",
    "# First, reload the clinical_data to make sure we're using the original data\n",
    "soft_file, matrix_file = geo_get_relevant_filepaths(in_cohort_dir)\n",
    "background_info, clinical_data = get_background_and_clinical_data(matrix_file)\n",
    "\n",
    "# Print the sample IDs to understand the data structure\n",
    "print(\"Sample IDs in clinical data:\")\n",
    "print(clinical_data.columns[:5], \"...\")  # Show first 5 sample IDs\n",
    "\n",
    "# Print the sample IDs in gene expression data\n",
    "print(\"Sample IDs in gene expression data:\")\n",
    "print(normalized_gene_data.columns[:5], \"...\")  # Show first 5 sample IDs\n",
    "\n",
    "# Extract clinical features using the actual sample IDs\n",
    "is_trait_available = trait_row is not None\n",
    "linked_data = None\n",
    "\n",
    "if is_trait_available:\n",
    "    # Extract clinical features with proper sample IDs\n",
    "    selected_clinical_df = geo_select_clinical_features(\n",
    "        clinical_df=clinical_data,\n",
    "        trait=trait,\n",
    "        trait_row=trait_row,\n",
    "        convert_trait=convert_trait,\n",
    "        age_row=age_row,\n",
    "        convert_age=convert_age if age_row is not None else None,\n",
    "        gender_row=gender_row,\n",
    "        convert_gender=convert_gender if gender_row is not None else None\n",
    "    )\n",
    "    \n",
    "    print(f\"Clinical data shape: {selected_clinical_df.shape}\")\n",
    "    print(f\"Clinical data preview: {preview_df(selected_clinical_df, n=3)}\")\n",
    "    \n",
    "    # Save the clinical data\n",
    "    os.makedirs(os.path.dirname(out_clinical_data_file), exist_ok=True)\n",
    "    selected_clinical_df.to_csv(out_clinical_data_file)\n",
    "    print(f\"Clinical data saved to {out_clinical_data_file}\")\n",
    "    \n",
    "    # Link clinical and genetic data\n",
    "    # Make sure both dataframes have compatible indices/columns\n",
    "    linked_data = geo_link_clinical_genetic_data(selected_clinical_df, normalized_gene_data)\n",
    "    print(f\"Linked data shape before handling missing values: {linked_data.shape}\")\n",
    "    \n",
    "    if linked_data.shape[0] == 0:\n",
    "        print(\"WARNING: No samples matched between clinical and genetic data!\")\n",
    "        # Create a sample dataset for demonstration\n",
    "        print(\"Using gene data with artificial trait values for demonstration\")\n",
    "        is_trait_available = False\n",
    "        is_biased = True\n",
    "        linked_data = pd.DataFrame(index=normalized_gene_data.columns)\n",
    "        linked_data[trait] = 1  # Placeholder\n",
    "    else:\n",
    "        # 3. Handle missing values\n",
    "        linked_data = handle_missing_values(linked_data, trait)\n",
    "        print(f\"Data shape after handling missing values: {linked_data.shape}\")\n",
    "        \n",
    "        # 4. Determine if trait and demographic features are biased\n",
    "        is_biased, linked_data = judge_and_remove_biased_features(linked_data, trait)\n",
    "        print(f\"Data shape after removing biased features: {linked_data.shape}\")\n",
    "else:\n",
    "    print(\"Trait data was determined to be unavailable in previous steps.\")\n",
    "    is_biased = True  # Set to True since we can't evaluate without trait data\n",
    "    linked_data = pd.DataFrame(index=normalized_gene_data.columns)\n",
    "    linked_data[trait] = 1  # Add a placeholder trait column\n",
    "    print(f\"Using placeholder data due to missing trait information, shape: {linked_data.shape}\")\n",
    "\n",
    "# 5. Validate and save cohort info\n",
    "is_usable = validate_and_save_cohort_info(\n",
    "    is_final=True,\n",
    "    cohort=cohort,\n",
    "    info_path=json_path,\n",
    "    is_gene_available=True,\n",
    "    is_trait_available=is_trait_available,\n",
    "    is_biased=is_biased,\n",
    "    df=linked_data,\n",
    "    note=\"Dataset contains gene expression data from multiple sclerosis patients, but there were issues linking clinical and genetic data.\"\n",
    ")\n",
    "\n",
    "# 6. Save linked data if usable\n",
    "if is_usable:\n",
    "    os.makedirs(os.path.dirname(out_data_file), exist_ok=True)\n",
    "    linked_data.to_csv(out_data_file)\n",
    "    print(f\"Linked data saved to {out_data_file}\")\n",
    "else:\n",
    "    print(\"Dataset deemed not usable for associational studies.\")"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 5
}