convert_csv_kgraw_format.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JdBjkgk0mneJ"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import re\n",
        "\n",
        "def convert_csv_kgraw_format(file_path, gene_column, fc_column, edge_label, paper, cellname, pval_column=None, pval_threshold=0.05):\n",
        "    \"\"\"\n",
        "    Load a dataset, extract relevant columns, clean the data, and prepare it for ALzKG.\n",
        "\n",
        "    Parameters:\n",
        "    - file_path: str, the path to the dataset file.\n",
        "    - gene_column: str, the column name containing gene names.\n",
        "    - fc_column: str, the column name containing fold change values.\n",
        "    - edge_label: str, the custom label to use as a prefix to up/ down\n",
        "    - paper: str, paper name\n",
        "    - cellname: str, celltype/state_name\n",
        "    - pval_column: str (optional), the column name containing p-values.\n",
        "    - pval_threshold: float (optional), threshold for filtering based on p-values.\n",
        "\n",
        "    Returns:\n",
        "    - A pandas DataFrame processed according to the specified parameters.\n",
        "    \"\"\"\n",
        "    # Load the dataset\n",
        "    data = pd.read_csv(file_path)\n",
        "\n",
        "    # Extract relevant columns\n",
        "    relevant_columns = [gene_column, fc_column] + ([pval_column] if pval_column is not None else [])\n",
        "    data = data.loc[:, relevant_columns]\n",
        "\n",
        "    # Clean gene names\n",
        "    data = data[~data[gene_column].apply(clean_data)]\n",
        "\n",
        "    # Filter rows based on p-value threshold and non-null criteria if pval_column is provided\n",
        "    if pval_column is not None:\n",
        "        data = data[(data[pval_column] < pval_threshold) & (~np.isnan(data[pval_column]))]\n",
        "        data.drop(columns=[pval_column], inplace=True)  # Drop the pval_column after filtering\n",
        "\n",
        "    # Convert fold change values to numeric and categorize with the custom edge label\n",
        "    data[fc_column] = pd.to_numeric(data[fc_column], errors='coerce')\n",
        "    data[fc_column] = data[fc_column].apply(lambda x: categorize_fold_change(x, edge_label))\n",
        "\n",
        "    # Print unique edge types in CSV format with headers\n",
        "    unique_edges = data[fc_column].unique()\n",
        "    print('\"edge_type\",\"desc\"')\n",
        "    for edge in unique_edges:\n",
        "       print(f'\"{edge}\",\"...\"')\n",
        "\n",
        "    # Rename columns\n",
        "    data.rename(columns={gene_column: 'y_name', fc_column: 'relation'}, inplace=True)\n",
        "\n",
        "    # Add new columns\n",
        "    data['display_relation'] = data['relation'].apply(lambda x: shorten_relation(x))  # Define the 'shorten_relation' function based on your criteria\n",
        "    data['y_id'] = 'tbd'\n",
        "    data['y_type'] = 'gene/protein'\n",
        "    data['y_source'] = 'NCBI'\n",
        "    data['x_id'] = 'tbd'\n",
        "    data['x_type'] = 'celltype/state'\n",
        "    data['x_name'] = cellname\n",
        "    data['x_source'] = paper\n",
        "\n",
        "    # Reorder columns\n",
        "    final_columns_order = ['relation', 'display_relation', 'x_id', 'x_type', 'x_name', 'x_source', 'y_id', 'y_type', 'y_name', 'y_source']\n",
        "    data = data[final_columns_order]\n",
        "\n",
        "    # Save the processed DataFrame to a new CSV file\n",
        "    output_path = file_path.replace('.csv', '_kg.csv')\n",
        "    data.to_csv(output_path, index=False)\n",
        "\n",
        "def clean_data(name):\n",
        "    # Function to check if the input is NaN or matches patterns that are not valid gene names.\n",
        "    # Mathys data has a few rows with timestamps instead of gene names\n",
        "    if pd.isna(name):\n",
        "        return True\n",
        "    elif isinstance(name, str) and re.match(r\"^\\d{1,2}-[A-Za-z]{3,4}$\", name):\n",
        "        return True\n",
        "    return False\n",
        "\n",
        "def categorize_fold_change(x, edge_label):\n",
        "    \"\"\"\n",
        "    Categorize fold change values based on a custom edge label.\n",
        "\n",
        "    Parameters:\n",
        "    - x: float, the fold change value to categorize.\n",
        "    - edge_label: str, the custom edge label to prepend to 'up' or 'down'.\n",
        "\n",
        "    Returns:\n",
        "    - str, a string indicating the categorization of the fold change.\n",
        "    \"\"\"\n",
        "    if pd.isna(x):\n",
        "        return 'nan'  # Adjust as needed for NaN values\n",
        "    elif x > 0:\n",
        "        return f'{edge_label} up'\n",
        "    else:  # Assumes x < 0 since NaN is already handled\n",
        "        return f'{edge_label} down'\n",
        "\n",
        "def shorten_relation(relation):\n",
        "    \"\"\"\n",
        "    Generates a generic abbreviation for the relation description by taking the\n",
        "    first letter of each significant word in the phrase.\n",
        "\n",
        "    Parameters:\n",
        "    - relation: str, the full relation description to be abbreviated.\n",
        "\n",
        "    Returns:\n",
        "    - str, an abbreviated version of the relation description.\n",
        "    \"\"\"\n",
        "    # List of words to exclude from the abbreviation (feel free to expand this list)\n",
        "    exclude_words = {'and', 'of', 'to', 'in', 'for', 'with', 'the'}\n",
        "\n",
        "    # Split the relation into words, exclude certain words, and then take the first letter of each remaining word\n",
        "    abbreviation = ''.join(word[0].upper() for word in relation.split() if word.lower() not in exclude_words)\n",
        "\n",
        "    return abbreviation\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Example Usage\n",
        "# Import the drive module from Google Colab for file access, mount Google Drive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "# File path for the dataset to be added to PrimeKG, each celltype is being processed as separate CSV files\n",
        "file_path = \"/content/drive/My Drive/primekg_files/Mic.csv\"\n",
        "\n",
        "# Specify the columns for gene names, p-values, and fold change (can be one or more columns dependent on dataset)\n",
        "gene_column = 'Gene'\n",
        "pval_column = 'IndModel.adj.pvals'\n",
        "fc_column = 'IndModel.FC'\n",
        "\n",
        "# Process the dataset\n",
        "convert_csv_kgraw_format(\n",
        "    file_path=file_path,\n",
        "    gene_column=gene_column,\n",
        "    fc_column=fc_column,\n",
        "    edge_label = \"no-pathology vs pathology mathys\",\n",
        "    paper = \"Mathys et al 2019\",\n",
        "    cellname = \"Mic\",\n",
        "    pval_column=pval_column,\n",
        "    pval_threshold=0.05\n",
        ")\n"
      ],
      "metadata": {
        "id": "NPTRfLR_o9qh"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}