{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd83b4bd",
   "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 = \"GSE131281\"\n",
    "\n",
    "# Input paths\n",
    "in_trait_dir = \"../../input/GEO/Multiple_sclerosis\"\n",
    "in_cohort_dir = \"../../input/GEO/Multiple_sclerosis/GSE131281\"\n",
    "\n",
    "# Output paths\n",
    "out_data_file = \"../../output/preprocess/Multiple_sclerosis/GSE131281.csv\"\n",
    "out_gene_data_file = \"../../output/preprocess/Multiple_sclerosis/gene_data/GSE131281.csv\"\n",
    "out_clinical_data_file = \"../../output/preprocess/Multiple_sclerosis/clinical_data/GSE131281.csv\"\n",
    "json_path = \"../../output/preprocess/Multiple_sclerosis/cohort_info.json\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15d7b3f0",
   "metadata": {},
   "source": [
    "### Step 1: Initial Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3142c7d0",
   "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": "591f33b4",
   "metadata": {},
   "source": [
    "### Step 2: Dataset Analysis and Clinical Feature Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1936691e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import json\n",
    "from typing import Dict, Any, Optional, Callable\n",
    "\n",
    "# 1. Gene Expression Data Availability\n",
    "# Based on the series summary, this dataset contains gene expression data for MS cortical grey matter.\n",
    "is_gene_available = True\n",
    "\n",
    "# 2. Variable Availability and Data Type Conversion\n",
    "# 2.1 Data Availability\n",
    "\n",
    "# For trait (Multiple Sclerosis status):\n",
    "# From the background information, samples are from MS cases and controls.\n",
    "# The \"ms type\" in row 5 can help us identify MS cases vs controls.\n",
    "# Patient IDs starting with 'M' are MS cases, and those starting with 'C' are controls.\n",
    "trait_row = 0  # patient id (derived from the first character)\n",
    "\n",
    "# For age:\n",
    "# \"age at death\" is available in row 2\n",
    "age_row = 2\n",
    "\n",
    "# For gender:\n",
    "# \"Sex\" is available in row 1\n",
    "gender_row = 1\n",
    "\n",
    "# 2.2 Data Type Conversion Functions\n",
    "\n",
    "def convert_trait(value: str) -> int:\n",
    "    \"\"\"Convert patient ID to binary trait (MS = 1, Control = 0).\"\"\"\n",
    "    if value is None:\n",
    "        return None\n",
    "    \n",
    "    # Extract value after \"patient id: \"\n",
    "    if \"patient id:\" in value:\n",
    "        patient_id = value.split(\"patient id:\")[1].strip()\n",
    "        # Check if the ID starts with 'M' (MS case) or 'C' (control)\n",
    "        if patient_id.startswith('M'):\n",
    "            return 1  # MS case\n",
    "        elif patient_id.startswith('C'):\n",
    "            return 0  # Control\n",
    "    \n",
    "    return None\n",
    "\n",
    "def convert_age(value: str) -> Optional[float]:\n",
    "    \"\"\"Convert age at death to a continuous value.\"\"\"\n",
    "    if value is None:\n",
    "        return None\n",
    "    \n",
    "    if \"age at death:\" in value:\n",
    "        try:\n",
    "            age_str = value.split(\"age at death:\")[1].strip()\n",
    "            return float(age_str)\n",
    "        except:\n",
    "            return None\n",
    "    \n",
    "    return None\n",
    "\n",
    "def convert_gender(value: str) -> Optional[int]:\n",
    "    \"\"\"Convert gender to binary (Female = 0, Male = 1).\"\"\"\n",
    "    if value is None:\n",
    "        return None\n",
    "    \n",
    "    if \"Sex:\" in value:\n",
    "        sex = value.split(\"Sex:\")[1].strip()\n",
    "        if sex == 'F':\n",
    "            return 0  # Female\n",
    "        elif sex == 'M':\n",
    "            return 1  # Male\n",
    "    \n",
    "    return None\n",
    "\n",
    "# 3. Save Metadata\n",
    "# Trait data is available if trait_row is not None\n",
    "is_trait_available = trait_row is not None\n",
    "\n",
    "# Initial filtering on usability\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",
    "if trait_row is not None:\n",
    "    # Create a DataFrame from the sample characteristics dictionary\n",
    "    # We need to recreate the clinical data from the sample characteristics dictionary\n",
    "    sample_chars = {\n",
    "        0: ['patient id: M06', 'patient id: M34', 'patient id: M01', 'patient id: C18', 'patient id: M44', 'patient id: M16', 'patient id: C25', 'patient id: C27', 'patient id: M33', 'patient id: M60', 'patient id: C14', 'patient id: M23', 'patient id: C15', 'patient id: C09', 'patient id: C20', 'patient id: C21', 'patient id: M14', 'patient id: M15', 'patient id: M30', 'patient id: M57', 'patient id: M32', 'patient id: M53', 'patient id: C26', 'patient id: M09', 'patient id: M56', 'patient id: M61', 'patient id: M03', 'patient id: C17', 'patient id: C13', 'patient id: C45'],\n",
    "        1: ['Sex: F', 'Sex: M'],\n",
    "        2: ['age at death: 58', 'age at death: 92', 'age at death: 56', 'age at death: 35', 'age at death: 80', 'age at death: 84', 'age at death: 75', 'age at death: 38', 'age at death: 59', 'age at death: 77', 'age at death: 78', 'age at death: 64', 'age at death: 95', 'age at death: 60', 'age at death: 51', 'age at death: 39', 'age at death: 47', 'age at death: 87', 'age at death: 88', 'age at death: 61', 'age at death: 73', 'age at death: 49', 'age at death: 89', 'age at death: 70', 'age at death: 45']\n",
    "    }\n",
    "    \n",
    "    # Convert sample characteristics to a proper DataFrame format for geo_select_clinical_features\n",
    "    clinical_data = pd.DataFrame(sample_chars)\n",
    "    \n",
    "    # Extract clinical features\n",
    "    clinical_features = 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 features\n",
    "    preview = preview_df(clinical_features)\n",
    "    print(\"Preview of extracted clinical features:\")\n",
    "    print(preview)\n",
    "    \n",
    "    # Create directory if it doesn't exist\n",
    "    os.makedirs(os.path.dirname(out_clinical_data_file), exist_ok=True)\n",
    "    \n",
    "    # Save clinical features to CSV\n",
    "    clinical_features.to_csv(out_clinical_data_file, index=False)\n",
    "    print(f\"Clinical features saved to {out_clinical_data_file}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f689d405",
   "metadata": {},
   "source": [
    "### Step 3: Dataset Analysis and Clinical Feature Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b603821",
   "metadata": {},
   "outputs": [],
   "source": [
    "I'll provide improved code to better locate and parse the data files for this project.\n",
    "\n",
    "```python\n",
    "import os\n",
    "import pandas as pd\n",
    "import json\n",
    "import numpy as np\n",
    "from typing import Optional, Callable, Dict, Any, List\n",
    "import glob\n",
    "import re\n",
    "\n",
    "# Check if gene expression data is likely available\n",
    "gene_files = glob.glob(os.path.join(in_cohort_dir, \"*.txt\")) + \\\n",
    "             glob.glob(os.path.join(in_cohort_dir, \"*.csv\")) + \\\n",
    "             glob.glob(os.path.join(in_cohort_dir, \"*matrix*\")) + \\\n",
    "             glob.glob(os.path.join(in_cohort_dir, \"*Series-Matrix*\"))\n",
    "\n",
    "# Look for files that could contain gene expression data\n",
    "is_gene_available = False\n",
    "for file in gene_files:\n",
    "    # Check file size (gene expression files are typically large)\n",
    "    if os.path.getsize(file) > 100000:  # 100KB minimum size\n",
    "        is_gene_available = True\n",
    "        break\n",
    "\n",
    "# Look for clinical/sample information using broader patterns\n",
    "clinical_files = glob.glob(os.path.join(in_cohort_dir, \"*sample*.csv\")) + \\\n",
    "                 glob.glob(os.path.join(in_cohort_dir, \"*clinical*.csv\")) + \\\n",
    "                 glob.glob(os.path.join(in_cohort_dir, \"*character*.csv\")) + \\\n",
    "                 glob.glob(os.path.join(in_cohort_dir, \"*phenotype*.csv\")) + \\\n",
    "                 glob.glob(os.path.join(in_cohort_dir, \"*sample*.txt\")) + \\\n",
    "                 glob.glob(os.path.join(in_cohort_dir, \"*clinical*.txt\")) + \\\n",
    "                 glob.glob(os.path.join(in_cohort_dir, \"*pheno*.txt\"))\n",
    "\n",
    "# If no clinical files found, look in series matrix files which might contain clinical data\n",
    "if not clinical_files:\n",
    "    matrix_files = glob.glob(os.path.join(in_cohort_dir, \"*matrix*\")) + \\\n",
    "                   glob.glob(os.path.join(in_cohort_dir, \"*Series-Matrix*\"))\n",
    "    for file in matrix_files:\n",
    "        if os.path.exists(file) and os.path.getsize(file) > 0:\n",
    "            clinical_files = [file]\n",
    "            break\n",
    "\n",
    "clinical_data = pd.DataFrame()\n",
    "trait_row = None\n",
    "age_row = None\n",
    "gender_row = None\n",
    "\n",
    "# Try to load clinical data if available\n",
    "if clinical_files:\n",
    "    for file in clinical_files:\n",
    "        try:\n",
    "            if file.endswith('.csv'):\n",
    "                df = pd.read_csv(file)\n",
    "            else:  # Assume it's a text file\n",
    "                # For series matrix files, we need to extract sample characteristics\n",
    "                with open(file, 'r') as f:\n",
    "                    lines = f.readlines()\n",
    "                \n",
    "                sample_info_lines = []\n",
    "                in_sample_section = False\n",
    "                for line in lines:\n",
    "                    if line.startswith('!Sample_'):\n",
    "                        in_sample_section = True\n",
    "                        sample_info_lines.append(line.strip())\n",
    "                    elif in_sample_section and not line.startswith('!'):\n",
    "                        in_sample_section = False\n",
    "                \n",
    "                if sample_info_lines:\n",
    "                    # Convert to DataFrame\n",
    "                    sample_data = []\n",
    "                    for line in sample_info_lines:\n",
    "                        parts = line.split('=', 1)\n",
    "                        if len(parts) == 2:\n",
    "                            key = parts[0].strip('! \\t\\n\\r')\n",
    "                            values = parts[1].strip().split('\\t')\n",
    "                            sample_data.append([key] + values)\n",
    "                    \n",
    "                    if sample_data:\n",
    "                        df = pd.DataFrame(sample_data)\n",
    "                    else:\n",
    "                        continue\n",
    "                else:\n",
    "                    # Try reading as a tab-delimited file\n",
    "                    df = pd.read_csv(file, sep='\\t')\n",
    "            \n",
    "            if not df.empty:\n",
    "                clinical_data = df\n",
    "                print(f\"Clinical data loaded from {file}\")\n",
    "                print(\"Clinical data preview:\")\n",
    "                print(clinical_data.head())\n",
    "                break\n",
    "        except Exception as e:\n",
    "            print(f\"Error reading {file}: {e}\")\n",
    "            continue\n",
    "\n",
    "    # Check unique values in each row to identify trait, age, and gender information\n",
    "    unique_values = {}\n",
    "    for i in range(len(clinical_data)):\n",
    "        try:\n",
    "            row_values = clinical_data.iloc[i, 1:].dropna().unique()\n",
    "            if len(row_values) > 0:\n",
    "                desc = clinical_data.iloc[i, 0]\n",
    "                unique_values[i] = {\n",
    "                    'description': str(desc),\n",
    "                    'values': [str(v) for v in row_values]\n",
    "                }\n",
    "        except:\n",
    "            continue\n",
    "    \n",
    "    print(\"\\nUnique values in sample characteristics:\")\n",
    "    for row, data in unique_values.items():\n",
    "        print(f\"Row {row} - {data['description']}: {data['values']}\")\n",
    "    \n",
    "    # 2.1 Trait row identification for Multiple Sclerosis\n",
    "    trait_row = None\n",
    "    for row, data in unique_values.items():\n",
    "        desc = str(data['description']).lower()\n",
    "        values = [str(v).lower() for v in data['values']]\n",
    "        \n",
    "        # Check for MS-related terms\n",
    "        if any(term in desc for term in ['disease', 'ms', 'sclerosis', 'diagnosis', 'status', 'condition', 'group', 'type']) or \\\n",
    "           any('ms' in v or 'multiple sclerosis' in v or 'control' in v or 'patient' in v or 'health' in v for v in values):\n",
    "            \n",
    "            # Check if there are multiple categories\n",
    "            categories = set()\n",
    "            for v in values:\n",
    "                if any(term in v for term in ['ms', 'multiple sclerosis', 'patient', 'case']):\n",
    "                    categories.add('ms')\n",
    "                elif any(term in v for term in ['control', 'healthy', 'normal']):\n",
    "                    categories.add('control')\n",
    "            \n",
    "            if len(categories) >= 2 or (len(categories) == 1 and len(values) < 3):\n",
    "                # If we have both categories or just one category with very few samples\n",
    "                # (suggesting it might be a filter-applied dataset)\n",
    "                trait_row = row\n",
    "                break\n",
    "    \n",
    "    # 2.2 Define conversion function for trait\n",
    "    def convert_trait(value):\n",
    "        if pd.isna(value):\n",
    "            return None\n",
    "        \n",
    "        value = str(value).lower()\n",
    "        if ':' in value:\n",
    "            value = value.split(':', 1)[1].strip()\n",
    "        \n",
    "        # Map to binary values: 1 for MS/patient, 0 for control/healthy\n",
    "        if any(term in value for term in ['ms', 'multiple sclerosis', 'patient', 'case']):\n",
    "            return 1\n",
    "        elif any(term in value for term in ['control', 'healthy', 'normal']):\n",
    "            return 0\n",
    "        else:\n",
    "            return None\n",
    "    \n",
    "    # 2.3 Age row identification\n",
    "    age_row = None\n",
    "    for row, data in unique_values.items():\n",
    "        desc = str(data['description']).lower()\n",
    "        values = data['values']\n",
    "        \n",
    "        if 'age' in desc and not 'stage' in desc:  # Avoid confusion with \"stage\"\n",
    "            # Check if there are numeric values that could represent ages\n",
    "            has_numbers = any(re.search(r'\\d+', v) for v in values)\n",
    "            if has_numbers:\n",
    "                age_row = row\n",
    "                break\n",
    "    \n",
    "    # 2.4 Define conversion function for age\n",
    "    def convert_age(value):\n",
    "        if pd.isna(value):\n",
    "            return None\n",
    "        \n",
    "        value = str(value)\n",
    "        if ':' in value:\n",
    "            value = value.split(':', 1)[1].strip()\n",
    "        \n",
    "        # Try to extract numeric age\n",
    "        try:\n",
    "            numbers = re.findall(r'\\d+\\.?\\d*', value)\n",
    "            if numbers:\n",
    "                return float(numbers[0])\n",
    "            else:\n",
    "                return None\n",
    "        except:\n",
    "            return None\n",
    "    \n",
    "    # 2.5 Gender row identification\n",
    "    gender_row = None\n",
    "    for row\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66c17157",
   "metadata": {},
   "source": [
    "### Step 4: Gene Data Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6367d4d3",
   "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": "769f0d80",
   "metadata": {},
   "source": [
    "### Step 5: Gene Identifier Review"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a53a700b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Based on the gene identifiers, I can see they are Illumina probe IDs (prefixed with ILMN_)\n",
    "# These are not human gene symbols but microarray probe identifiers that need to be mapped\n",
    "# to standard gene symbols for biological interpretation\n",
    "\n",
    "requires_gene_mapping = True\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f34c4d9",
   "metadata": {},
   "source": [
    "### Step 6: Gene Annotation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5fc887e",
   "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": "36edf955",
   "metadata": {},
   "source": [
    "### Step 7: Gene Identifier Mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9bf8233",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Identify the columns in gene annotation for probe IDs and gene symbols\n",
    "probe_id_col = 'ID'  # Column containing ILMN_* identifiers\n",
    "gene_symbol_col = 'Symbol'  # Column containing gene symbols\n",
    "\n",
    "# 2. Get a gene mapping dataframe\n",
    "# Extract the two columns from the gene annotation dataframe\n",
    "gene_mapping = get_gene_mapping(gene_annotation, probe_id_col, gene_symbol_col)\n",
    "\n",
    "# 3. Apply gene mapping to convert probe-level measurements to gene expression data\n",
    "# This handles the many-to-many relation between probes and genes\n",
    "gene_data = apply_gene_mapping(gene_data, gene_mapping)\n",
    "\n",
    "# Print the shape of the gene expression data after mapping\n",
    "print(f\"Gene data dimensions after mapping: {gene_data.shape[0]} genes × {gene_data.shape[1]} samples\")\n",
    "\n",
    "# Print the first few gene symbols to verify the mapping\n",
    "print(\"\\nFirst 20 gene symbols after mapping:\")\n",
    "print(gene_data.index[:20])\n",
    "\n",
    "# Save the gene data to file\n",
    "os.makedirs(os.path.dirname(out_gene_data_file), exist_ok=True)\n",
    "gene_data.to_csv(out_gene_data_file)\n",
    "print(f\"Mapped gene expression data saved to {out_gene_data_file}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b509aea5",
   "metadata": {},
   "source": [
    "### Step 8: Data Normalization and Linking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1419ece7",
   "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
}