sdABs-11CDR3-editing for jovan's data.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2cdeb43",
   "metadata": {},
   "outputs": [],
   "source": [
    "#this version of the program is using presets for the sdAb library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f692fb7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#This program is used for unpaired read illumina sequencing fastq files.  The goal here is to take in your\n",
    "#sequencing file, and to cut out reads that match your defined template.  In this case of a synthetic \n",
    "#sdAB library we know the exact sequences that should be constant before and after our randomized positions.\n",
    "#Using the user specified sequences we cut out those sequences and then translate them to AA sequences. \n",
    "# please note that the user specified sequences need to be in-frame (all of our mutants are in frame)\n",
    "from datetime import datetime\n",
    "from Bio.Seq import Seq\n",
    "from Bio import SeqIO\n",
    "import modin.pandas as pd #multithreading version of pandas\n",
    "from distributed import Client\n",
    "import os\n",
    "client = Client()\n",
    "\n",
    "# Directory containing the .fa files\n",
    "Output_directory = \"Output_Files\"\n",
    "cluster_directory = \"Clusters\"\n",
    "# Create the directory folders if it doesn't exist\n",
    "if not os.path.exists(Output_directory):\n",
    "    os.makedirs(Output_directory)\n",
    "if not os.path.exists(cluster_directory):\n",
    "    os.makedirs(cluster_directory)\n",
    "# Create the \"Logos\" folder if it doesn't exist\n",
    "logos_folder = \"Logos\"\n",
    "if not os.path.exists(logos_folder):\n",
    "    os.makedirs(logos_folder)\n",
    "# Directory containing the .fa files\n",
    "Scatterplot_directory = \"Scatterplots\"\n",
    "\n",
    "# Create the directory folder if it doesn't exist\n",
    "if not os.path.exists(Scatterplot_directory):\n",
    "    os.makedirs(Scatterplot_directory)\n",
    "\n",
    "def reverse_complement(seq):\n",
    "    \"\"\"Return the reverse complement of a DNA sequence\"\"\"\n",
    "    return str(Seq(seq).reverse_complement())\n",
    "\n",
    "\n",
    "# User-defined sequences in 5' to 3' direction - you can also add other startX and stopXs to the lists\n",
    "seqs_5to3 = {\n",
    "    \"start1\": \"GGTGGTTCCCTACGT\",\n",
    "    \"stop1\": \"ACCCAAGTC\",\n",
    "}\n",
    "\n",
    "# User-defined sequences in 3' to 5' direction - this is the same sequence you put above, just in reverse\n",
    "seqs_3to5 = {\n",
    "    \"start3\": \"GACTTGGGT\", #this should be the reverse complement of stop 1\n",
    "    \"stop3\": \"ACGTAGGGAACCACC\",#this should be the reverse complement of start1\n",
    "}\n",
    "\n",
    "# Convert 3' to 5' sequences to 5' to 3'\n",
    "seqs_5to3.update(\n",
    "    {f\"{key}_rc\": reverse_complement(val) for key, val in seqs_3to5.items()}\n",
    ")\n",
    "\n",
    "# Initialize an empty list to store results\n",
    "results = []\n",
    "\n",
    "# Iterate over each record in the FASTQ file\n",
    "for record in SeqIO.parse(\"Illumina_test_sdAB.fastq\", \"fastq\"):\n",
    "    # Extract the DNA sequence from the record\n",
    "    seq = str(record.seq)\n",
    "\n",
    "    # Iterate over the user-defined sequences\n",
    "    for seq_key, seq_val in seqs_5to3.items():\n",
    "        # Find the start and end indices of the sequence of interest\n",
    "        start_index = seq.find(seq_val)\n",
    "        end_index = seq.find(seqs_5to3[f\"{seq_key.replace('start', 'stop')}\"], start_index + len(seq_val))\n",
    "\n",
    "        # Check if the sequence of interest was found\n",
    "        if start_index != -1 and end_index != -1:\n",
    "            # Extract the DNA sequence between the start and stop sequences\n",
    "            dna_seq = seq[start_index + len(seq_val): end_index]\n",
    "\n",
    "            # Reverse complement the DNA sequence if the user-defined sequence was in the 3' to 5' direction\n",
    "            if seq_key.endswith(\"_rc\"):\n",
    "                dna_seq = reverse_complement(dna_seq)\n",
    "\n",
    "            # Translate the DNA sequence to amino acids\n",
    "            aa_seq = Seq(dna_seq).translate()\n",
    "\n",
    "            # Add the result to the list of results\n",
    "            results.append({\"Sequence\": aa_seq, \"KD\": \"1\"}) #this is where we will have to add KDs from TITEseq someday\n",
    "\n",
    "# Convert the results to a pandas DataFrame and write to an Excel file\n",
    "\n",
    "df = pd.DataFrame(results)\n",
    "df.to_excel(\"Output_Files/output-sdab-clusters.xlsx\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1d09489",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#this works, just has the future warning\n",
    "import matplotlib.pyplot as plt\n",
    "import Levenshtein as lev\n",
    "from matplotlib.pyplot import figure\n",
    "from sklearn.cluster import DBSCAN\n",
    "from Levenshtein import distance\n",
    "from scipy.spatial.distance import cdist\n",
    "import numpy as np\n",
    "from distributed import Client\n",
    "client = Client()\n",
    "import modin.pandas as pd\n",
    "# Define the framework sequences\n",
    "frameworks = {\n",
    "    'Framework1': 'LSCAAS',  #original value  'LSCAAS'\n",
    "    'Framework2': 'GWYRQAPGKER', #original value 'GWYRQAPGKER'\n",
    "    'Framework3': 'ADSVKGRFTISRDNAKNTVYLQMNSLKPEDTAVYYC',  #original value 'ADSVKGRFTISRDNAKNTVYLQMNSLKPEDTAVYYC'\n",
    "    'Framework4': 'YWGQG',     #original value 'YWGQG'\n",
    "}\n",
    "\n",
    "# Define the CDR loop positions relative to the framework sequences\n",
    "cdr_positions = {\n",
    "    'CDR1': ['Framework1', 'Framework2'],\n",
    "    'CDR2': ['Framework2', 'Framework3'], \n",
    "    'CDR3': ['Framework3', 'Framework4'],\n",
    "}\n",
    "\n",
    "# Load the data from the Excel file\n",
    "print(\"Reading CSV\")\n",
    "df = pd.read_csv('NSG_miseq_F_top200.csv')\n",
    "print(\"Starting Number of sequences \", len(df))\n",
    "print(\"Deleting sequences that do not contain one of the intended frameworks\")\n",
    "strings_to_check = {'LSCAAS', 'GWYRQAPGKER', 'ADSVKGRFTISRDNAKNTVYLQMNSLKPEDTAVYYC', 'YWGQG'}\n",
    "df['Sequence'] = df['Sequence'].str.strip()\n",
    "print(\"Remaining Sequences \",len(df))\n",
    "# Remove lines containing the asterisk character\n",
    "pd.set_option('display.max_rows', 2000)\n",
    "print(df)\n",
    "print(\"Removing sequences with stop codons\")\n",
    "df = df[~df.astype(str).apply(lambda x: x.str.contains('\\\\*')).any(axis=1)]\n",
    "print(\"Remaining Sequences \",len(df))\n",
    "# Check if all strings in `strings_to_check` are present in the 'Sequence' column\n",
    "df = df[df['Sequence'].apply(lambda x: all(string in x for string in strings_to_check))]\n",
    "print(\"Assigning random numbers to the KD column- Only use this if you have no TITE-seq values\")\n",
    "df['KD'] = np.random.randint(1, 1001, size=len(df))\n",
    "pd.set_option('display.max_rows', 2000)\n",
    "print(df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96bf147c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Extract the CDR loop sequences\n",
    "import collections\n",
    "print(\"Extracting CDR Loops\")\n",
    "cdr_seqs = {}\n",
    "for cdr, positions in cdr_positions.items():\n",
    "    start, end = positions\n",
    "    cdr_seqs[cdr] = [seq[seq.find(frameworks[start])+len(frameworks[start]):seq.find(frameworks[end])] for seq in df['Sequence']]\n",
    "print(\"Number of cdr_seqs \",len(cdr_seqs),\":\")\n",
    "print(cdr_seqs)\n",
    "# Calculate the frequency percentage of each CDR sequence as a percentage\n",
    "cdr_freqs = {}\n",
    "print(\"Calculating CDR Frequencies\")\n",
    "for cdr in cdr_seqs:\n",
    "    cdr_count = len(cdr_seqs[cdr])\n",
    "    cdr_seq_array = np.array(cdr_seqs[cdr])\n",
    "    seq_counts = collections.Counter(cdr_seq_array)\n",
    "    cdr_freqs[cdr] = [((count / cdr_count)* 100) for _, count in seq_counts.items()]\n",
    "print(\"CDR FREQs loop result\")\n",
    "print(cdr_freqs)\n",
    "print(\"CDR seq array\")\n",
    "print(cdr_seq_array)\n",
    "# Find the most common CDR sequence for each loop\n",
    "cdr_consensus_seqs = {}\n",
    "print(\"Identifying the most common CDR sequences for each loop\")\n",
    "for cdr in cdr_seqs:\n",
    "    cdr_freq_array = np.array(cdr_freqs[cdr])\n",
    "    max_freq_idx = np.argmax(cdr_freq_array)\n",
    "    cdr_consensus_seqs[cdr] = cdr_seqs[cdr][max_freq_idx]\n",
    "\n",
    "# Calculate the Levenshtein distance between each CDR sequence and the consensus sequence\n",
    "print(\"Calculating Levenshtein distance between each CDR and the most common CDR\")\n",
    "cdr_distances = {}\n",
    "for cdr in cdr_seqs:\n",
    "    cdr_distances[cdr] = [lev.distance(seq, cdr_consensus_seqs[cdr]) for seq in cdr_seqs[cdr]]\n",
    "\n",
    "# Create a new dataframe with the results, removing duplicate sequences\n",
    "print(\"Combining data to a single dataframe\")\n",
    "print(df)\n",
    "print(\"Dropping sequences that don't have CDR sequences\")\n",
    "df = df.dropna()\n",
    "print(df)\n",
    "# cdr_df = pd.DataFrame()\n",
    "# min_length = min(len(df), len(cdr_seqs['CDR1']), len(cdr_freqs['CDR1']), len(cdr_distances['CDR1']), len(cdr_seqs['CDR2']), len(cdr_freqs['CDR2']), len(cdr_distances['CDR2']), len(cdr_seqs['CDR3']), len(cdr_freqs['CDR3']), len(cdr_distances['CDR3']))\n",
    "# for i in range(min_length):\n",
    "#     cdr_df = pd.concat([cdr_df, pd.DataFrame({'Sequence': df['Sequence'].iloc[i],\n",
    "#                                        'KD': df['KD'].iloc[i],\n",
    "#                                        'CDR1 Seq': cdr_seqs['CDR1'][i],\n",
    "#                                        'CDR1 Freq': cdr_freqs['CDR1'][i],\n",
    "#                                        'CDR1 Distance': cdr_distances['CDR1'][i],\n",
    "#                                        'CDR2 Seq': cdr_seqs['CDR2'][i],\n",
    "#                                        'CDR2 Freq': cdr_freqs['CDR2'][i],\n",
    "#                                        'CDR2 Distance': cdr_distances['CDR2'][i],\n",
    "#                                        'CDR3 Seq': cdr_seqs['CDR3'][i],\n",
    "#                                        'CDR3 Freq': cdr_freqs['CDR3'][i],\n",
    "#                                        'CDR3 Distance': cdr_distances['CDR3'][i]}, index=[i])],\n",
    "#                         ignore_index=True)\n",
    "# import collections\n",
    "\n",
    "# # ...\n",
    "\n",
    "# Calculate the frequency percentage of each CDR sequence as a percentage\n",
    "print(\"Calculating CDR Frequencies\")\n",
    "for cdr in cdr_seqs:\n",
    "    cdr_count = len(cdr_seqs[cdr])\n",
    "    cdr_seq_array = np.array(cdr_seqs[cdr])\n",
    "    seq_counts = collections.Counter(cdr_seq_array)\n",
    "    df[f'{cdr} Seq'] = pd.Series(cdr_seq_array)\n",
    "    df[f'{cdr} Freq'] = pd.Series([((count / cdr_count)* 100) for _, count in seq_counts.items()])\n",
    "\n",
    "# Calculate the Levenshtein distance between each CDR sequence and the consensus sequence\n",
    "print(\"Calculating Levenshtein distance between each CDR and the most common CDR\")\n",
    "for cdr in cdr_seqs:\n",
    "    df[f'{cdr} Distance'] = pd.Series([lev.distance(seq, cdr_consensus_seqs[cdr]) for seq in cdr_seqs[cdr]])\n",
    "\n",
    "# ...\n",
    "\n",
    "\n",
    "print(\"Number of sequences after CDR1, CDR2, and CDR3 Extraction \", len(df) )\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fae3089",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_rows', 2000)\n",
    "df['CDR1 Freq'] = (df['CDR1 Seq'].value_counts(normalize=True)* 100)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af589b8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Removing duplicated full sequences\")\n",
    "cdr_df = cdr_df.drop_duplicates(subset=['Sequence'])\n",
    "print(\"Number of sequences after dropping duplicated full sequences \", len(cdr_df))\n",
    "#cdr_df[['Sequence Freq']] = cdr_df[['Sequence Freq']].apply(lambda x: round(x, 2))\n",
    "cdr_df[['CDR1 Freq']] = cdr_df[['CDR1 Freq']].apply(lambda x: round(x, 2))\n",
    "cdr_df[['CDR2 Freq']] = cdr_df[['CDR2 Freq']].apply(lambda x: round(x, 2))\n",
    "cdr_df[['CDR3 Freq']] = cdr_df[['CDR3 Freq']].apply(lambda x: round(x, 2))\n",
    "\n",
    "print(cdr_df)\n",
    "# Define a function to compute the pairwise distance matrix between all sequences\n",
    "#def pairwise_distance_matrix(sequences):\n",
    "#    n = len(sequences)\n",
    "#    dist_matrix = np.zeros((n, n))\n",
    "#    for i in range(n):\n",
    "#        for j in range(i+1, n):\n",
    "#            dist_matrix[i, j] = distance(sequences[i], sequences[j])\n",
    "#            dist_matrix[j, i] = dist_matrix[i, j]\n",
    "#    return dist_matrix\n",
    "\n",
    "# Compute the pairwise distance matrix - might need something here\n",
    "print(\"Computing Distance Matrix (Levenshtein) for Full Sequence\")\n",
    "sequences = cdr_df['Sequence'].tolist()\n",
    "dist_matrix = np.zeros((len(sequences), len(sequences)))\n",
    "for i in range(len(sequences)):\n",
    "    for j in range(i+1, len(sequences)):\n",
    "        dist_matrix[i, j] = lev.distance(sequences[i], sequences[j])\n",
    "        dist_matrix[j, i] = dist_matrix[i, j]\n",
    "\n",
    "#dist_matrix = pairwise_distance_matrix(cdr_df['Sequence'].values)\n",
    "#dist_matrix = pairwise_distance_matrix(cdr_df['CDR1 Seq'].values)\n",
    "#dist_matrix = pairwise_distance_matrix(cdr_df['CDR2 Seq'].values)\n",
    "#dist_matrix = pairwise_distance_matrix(cdr_df['CDR3 Seq'].values)\n",
    "\n",
    "print(dist_matrix)\n",
    "# Run DBSCAN on the distance matrix\n",
    "dbscan = DBSCAN(metric='precomputed', eps=1.5, min_samples=2)\n",
    "dbscan.fit(dist_matrix)\n",
    "\n",
    "# Extract the cluster labels\n",
    "cluster_labels = dbscan.labels_\n",
    "\n",
    "# Print the number of clusters found\n",
    "n_clusters = len(set(cluster_labels)) - (1 if -1 in cluster_labels else 0)\n",
    "print('Number of clusters found:', n_clusters)\n",
    "\n",
    "# Add the cluster labels to the dataframe\n",
    "cdr_df['Sequence Cluster'] = cluster_labels\n",
    "\n",
    "print(\"Computing Distance Matrix (Levenshtein) for CDR1\")\n",
    "sequences = cdr_df['CDR1 Seq'].tolist()\n",
    "dist_matrix = np.zeros((len(sequences), len(sequences)))\n",
    "for i in range(len(sequences)):\n",
    "    for j in range(i+1, len(sequences)):\n",
    "        dist_matrix[i, j] = lev.distance(sequences[i], sequences[j])\n",
    "        dist_matrix[j, i] = dist_matrix[i, j]\n",
    "\n",
    "# Run DBSCAN on the distance matrix\n",
    "dbscan = DBSCAN(metric='precomputed', eps=0.5, min_samples=2)\n",
    "dbscan.fit(dist_matrix)\n",
    "\n",
    "# Extract the cluster labels\n",
    "cluster_labels = dbscan.labels_\n",
    "cdr_df['CDR1 Cluster'] = cluster_labels\n",
    "# Print the number of clusters found\n",
    "n_clusters = len(set(cluster_labels)) - (1 if -1 in cluster_labels else 0)\n",
    "print('Number of clusters found for CDR1:', n_clusters)\n",
    "\n",
    "\n",
    "print(\"Computing Distance Matrix (Levenshtein) for CDR2\")\n",
    "sequences = cdr_df['CDR2 Seq'].tolist()\n",
    "dist_matrix = np.zeros((len(sequences), len(sequences)))\n",
    "for i in range(len(sequences)):\n",
    "    for j in range(i+1, len(sequences)):\n",
    "        dist_matrix[i, j] = lev.distance(sequences[i], sequences[j])\n",
    "        dist_matrix[j, i] = dist_matrix[i, j]\n",
    "# Run DBSCAN on the distance matrix\n",
    "dbscan = DBSCAN(metric='precomputed', eps=1.0, min_samples=2)\n",
    "dbscan.fit(dist_matrix)\n",
    "\n",
    "# Extract the cluster labels\n",
    "cluster_labels = dbscan.labels_\n",
    "cdr_df['CDR2 Cluster'] = cluster_labels\n",
    "# Print the number of clusters found\n",
    "n_clusters = len(set(cluster_labels)) - (1 if -1 in cluster_labels else 0)\n",
    "print('Number of clusters found for CDR2:', n_clusters)\n",
    "        \n",
    "cdr_df['CDR2 Cluster'] = cluster_labels\n",
    "\n",
    "print(\"Computing Distance Matrix (Levenshtein) for CDR3\")\n",
    "sequences = cdr_df['CDR3 Seq'].tolist()\n",
    "dist_matrix = np.zeros((len(sequences), len(sequences)))\n",
    "for i in range(len(sequences)):\n",
    "    for j in range(i+1, len(sequences)):\n",
    "        dist_matrix[i, j] = lev.distance(sequences[i], sequences[j])\n",
    "        dist_matrix[j, i] = dist_matrix[i, j]\n",
    "# Run DBSCAN on the distance matrix\n",
    "dbscan = DBSCAN(metric='precomputed', eps=1.0, min_samples=2)\n",
    "dbscan.fit(dist_matrix)\n",
    "\n",
    "# Extract the cluster labels\n",
    "cluster_labels = dbscan.labels_\n",
    "cdr_df['CDR2 Cluster'] = cluster_labels\n",
    "# Print the number of clusters found\n",
    "n_clusters = len(set(cluster_labels)) - (1 if -1 in cluster_labels else 0)\n",
    "print('Number of clusters found for CDR3:', n_clusters)\n",
    "        \n",
    "cdr_df['CDR3 Cluster'] = cluster_labels\n",
    "print(cdr_df)\n",
    "from Bio.SeqUtils.ProtParam import ProteinAnalysis\n",
    "import modin.pandas as pd\n",
    "\n",
    "# Define a function to calculate GRAVY and pI\n",
    "def calculate_gravy_and_pi(seq):\n",
    "    # Create a ProteinAnalysis object for the amino acid sequence\n",
    "    protein = ProteinAnalysis(seq)\n",
    "    \n",
    "    # Calculate GRAVY\n",
    "    gravy = protein.gravy()\n",
    "    \n",
    "    # Calculate pI\n",
    "    pi = protein.isoelectric_point()\n",
    "    \n",
    "    return gravy, pi\n",
    "\n",
    "# Apply the function to the 'CDR1 Seq' column and store the results in new columns\n",
    "print(\"Calculating Gravy and pI\")\n",
    "cdr_df[['GRAVY_Index', 'pI']] = pd.DataFrame(cdr_df['CDR1 Seq'].apply(calculate_gravy_and_pi).tolist(), index=cdr_df.index)\n",
    "cdr_df[['GRAVY_Index', 'pI']] = pd.DataFrame(cdr_df['CDR2 Seq'].apply(calculate_gravy_and_pi).tolist(), index=cdr_df.index)\n",
    "cdr_df[['GRAVY_Index', 'pI']] = pd.DataFrame(cdr_df['CDR3 Seq'].apply(calculate_gravy_and_pi).tolist(), index=cdr_df.index)\n",
    "\n",
    "\n",
    "\n",
    "cdr_df = cdr_df.reset_index(drop=True)\n",
    "# Save the results to a new Excel file\n",
    "print(\"Printing Output_Files/sdAB_distances.xlsx\")\n",
    "cdr_df.to_excel('Output_Files/sdAB_distances.xlsx', index=False)\n",
    "\n",
    "# Create scatterplots for each CDR loop\n",
    "print(\"Output Excel Created\")\n",
    "for cdr in cdr_distances:\n",
    "    plt.scatter(cdr_df['CDR1 Distance'], cdr_df['KD'], c=cluster_labels)\n",
    "    plt.xlabel('Levenshtein Distance from Most Common Sequence for '+cdr)\n",
    "    plt.ylabel('KD')\n",
    "    plt.title(\"Distances vs KD for \"+cdr)\n",
    "    for i, seq in enumerate(cdr_seqs[cdr]):\n",
    "        plt.annotate(seq, (cdr_distances[cdr][i], df['KD'][i]))\n",
    "    plt.savefig('Scatterplots/Scatter_with_sequences.png', dpi=300)\n",
    "    plt.show()\n",
    "print(\"Output Scatterplot for Lev Distance vs KD\")    \n",
    "for cdr in cdr_distances:\n",
    "    plt.scatter(cdr_df['CDR1 Distance'], cdr_df['KD'], c=cluster_labels)\n",
    "    plt.xlabel('Levenshtein Distance from Most Common Sequence for '+cdr)\n",
    "    plt.ylabel('KD')\n",
    "    plt.title(\"Distances vs KD for \"+cdr)\n",
    "    plt.savefig('Scatterplots/Scatter_only_KD_distance.png', dpi=300)\n",
    "    plt.show()\n",
    "print(\"Output Scatterplot for Lev Distance vs KD\")\n",
    "for cdr in cdr_distances:\n",
    "    plt.scatter(cdr_df['CDR1 Distance'], cdr_df['GRAVY_Index'], c=cluster_labels)\n",
    "    plt.xlabel('Levenshtein Distance from Most Common Sequence for '+cdr)\n",
    "    plt.ylabel('GRAVY Index')\n",
    "    plt.title(\"Distances vs GRAVY Index for \"+cdr)\n",
    "    plt.savefig('Scatterplots/Scatter_only_GRAVY_distance.png', dpi=300)\n",
    "    plt.show()\n",
    "print(\"Output Scatterplot for Lev Distance vs GRAVY Index\")\n",
    "for cdr in cdr_distances:\n",
    "    plt.scatter(cdr_df['CDR1 Distance'], cdr_df['pI'], c=cluster_labels)\n",
    "    plt.xlabel('Levenshtein Distance from Most Common Sequence for '+cdr)\n",
    "    plt.ylabel('pI')\n",
    "    plt.title(\"Distances vs pI for \"+cdr)\n",
    "    plt.savefig('Scatterplots/Scatter_only_pI_distance.png', dpi=300)\n",
    "    plt.show()\n",
    "print(\"Output Scatterplot for Lev Distance vs pI\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2915dce",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a35f8b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#this is how you choose an eps value for dbscan\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "\n",
    "# Assuming 'cdr_df' is your dataframe and 'CDR2 Distance' is the column name\n",
    "X = cdr_df['CDR3 Distance'].values.reshape(-1, 1)\n",
    "\n",
    "# Calculate k-distance graph\n",
    "k = 4  # Choose the desired value of k\n",
    "nbrs = NearestNeighbors(n_neighbors=k).fit(X)\n",
    "distances, indices = nbrs.kneighbors(X)\n",
    "\n",
    "# Sort distances in descending order\n",
    "k_distances = np.sort(distances[:, -1])[::-1]\n",
    "\n",
    "# Plot k-distance graph\n",
    "plt.plot(np.arange(1, len(X)+1), k_distances,marker='o', linestyle='-', color='blue')\n",
    "plt.xlabel('Data Points')\n",
    "plt.ylabel(f'{k}-Distance')\n",
    "plt.title(f'K-Distance Plot (k={k})')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "baa8f33d",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.ioff()\n",
    "\n",
    "for cdr in cdr_distances:\n",
    "    # Create a scatter plot directly from the dataframe\n",
    "    cdr_df.plot.scatter(x='CDR1 Distance', y='KD', c=cluster_labels, title=\"Distances vs KD for \" + cdr)\n",
    "\n",
    "    # Add annotations to the plot\n",
    "    for i, seq in enumerate(cdr_seqs[cdr]):\n",
    "        plt.annotate(seq, (cdr_distances[cdr][i], df['KD'][i]))\n",
    "\n",
    "    # Save the figure\n",
    "    plt.savefig('Scatterplots/Scatter_with_sequences_' + cdr + '.png', dpi=300)\n",
    "\n",
    "    # Clear the current plot\n",
    "    plt.clf()\n",
    "\n",
    "# Show the plots if needed\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f29e29cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Bio.Seq import Seq\n",
    "from Bio.SeqRecord import SeqRecord\n",
    "from Bio.Align import MultipleSeqAlignment\n",
    "from Bio import AlignIO\n",
    "import modin.pandas as pd\n",
    "\n",
    "# Read the amino acid sequences from the CDR1 Seq column of the dataframe\n",
    "sequences = [SeqRecord(Seq(seq), id=str(i+1)) for i, seq in enumerate(cdr_df['CDR1 Seq'])]\n",
    "\n",
    "# Align the sequences\n",
    "alignment = MultipleSeqAlignment(sequences)\n",
    "\n",
    "# Write the aligned sequences to a file in FASTA format\n",
    "with open('Clusters/cdr1_global_alignment.fa', 'w') as f:\n",
    "    AlignIO.write(alignment, f, 'fasta')\n",
    "print(\"Global alignment completed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14c9c569",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from Bio import SeqIO\n",
    "from Bio.Seq import Seq\n",
    "from Bio.SeqRecord import SeqRecord\n",
    "from Bio.Align import MultipleSeqAlignment\n",
    "\n",
    "# Read the sequences from the DataFrame\n",
    "cdr_sequences = cdr_df['CDR1 Seq'].tolist()\n",
    "\n",
    "# Group sequences by cluster\n",
    "groups = cdr_df.groupby('Cluster')\n",
    "for cluster, group in groups:\n",
    "    # Create a list of SeqRecord objects\n",
    "    seq_records = []\n",
    "    for i, seq in enumerate(group['CDR1 Seq']):\n",
    "        seq_record = SeqRecord(Seq(seq), id=f'seq{i+1}')\n",
    "        seq_records.append(seq_record)\n",
    "    \n",
    "    # Align the sequences\n",
    "    alignment = MultipleSeqAlignment(seq_records)\n",
    "    \n",
    "    # Write the aligned sequences to a file in FASTA format\n",
    "    with open(f'Clusters/cdr1_alignment_{cluster}.fa', 'w') as f:\n",
    "        SeqIO.write(alignment, f, 'fasta')\n",
    "print(\"CDR1 Cluster sequence alignment completed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac8b7fde",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Bio import SeqIO\n",
    "from Bio.Seq import Seq\n",
    "from Bio.SeqRecord import SeqRecord\n",
    "from Bio.Align import MultipleSeqAlignment\n",
    "\n",
    "# Read the sequences from the DataFrame\n",
    "cdr_sequences = cdr_df['CDR2 Seq'].tolist()\n",
    "\n",
    "# Group sequences by cluster\n",
    "groups = cdr_df.groupby('Cluster')\n",
    "for cluster, group in groups:\n",
    "    # Create a list of SeqRecord objects\n",
    "    seq_records = []\n",
    "    for i, seq in enumerate(group['CDR2 Seq']):\n",
    "        seq_record = SeqRecord(Seq(seq), id=f'seq{i+1}')\n",
    "        seq_records.append(seq_record)\n",
    "    \n",
    "    # Align the sequences\n",
    "    alignment = MultipleSeqAlignment(seq_records)\n",
    "    \n",
    "    # Write the aligned sequences to a file in FASTA format\n",
    "    with open(f'Clusters/cdr2_alignment_{cluster}.fa', 'w') as f:\n",
    "        SeqIO.write(alignment, f, 'fasta')\n",
    "print(\"CDR2 Cluster sequence alignment completed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea70e708",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Bio import SeqIO\n",
    "from Bio.Seq import Seq\n",
    "from Bio.SeqRecord import SeqRecord\n",
    "from Bio.Align import MultipleSeqAlignment\n",
    "\n",
    "# Read the sequences from the DataFrame\n",
    "cdr_sequences = cdr_df['CDR3 Seq'].tolist()\n",
    "\n",
    "# Group sequences by cluster\n",
    "groups = cdr_df.groupby('Cluster')\n",
    "for cluster, group in groups:\n",
    "    # Create a list of SeqRecord objects\n",
    "    seq_records = []\n",
    "    for i, seq in enumerate(group['CDR3 Seq']):\n",
    "        seq_record = SeqRecord(Seq(seq), id=f'seq{i+1}')\n",
    "        seq_records.append(seq_record)\n",
    "    \n",
    "    # Align the sequences\n",
    "    alignment = MultipleSeqAlignment(seq_records)\n",
    "    \n",
    "    # Write the aligned sequences to a file in FASTA format\n",
    "    with open(f'Clusters/cdr3_alignment_{cluster}.fa', 'w') as f:\n",
    "        SeqIO.write(alignment, f, 'fasta')\n",
    "print(\"CDR2 Cluster sequence alignment completed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ff43a01",
   "metadata": {},
   "outputs": [],
   "source": [
    "#this just makes one logo\n",
    "import logomaker\n",
    "from Bio import AlignIO\n",
    "\n",
    "# Read in the alignment file in FASTA format\n",
    "alignment = AlignIO.read(\"Clusters/cdr1_alignment_0.fa\", \"fasta\")\n",
    "\n",
    "# Convert the alignment to a list of sequences\n",
    "sequences = [str(record.seq) for record in alignment]\n",
    "\n",
    "# Convert the sequences to a pandas dataframe\n",
    "alignment_df = logomaker.alignment_to_matrix(sequences)\n",
    "\n",
    "# Create the sequence logo\n",
    "logo = logomaker.Logo(alignment_df, color_scheme='dmslogo_funcgroup')\n",
    "# Customize the logo appearance\n",
    "logo.style_spines(visible=False)\n",
    "logo.ax.xaxis.set_tick_params(labelsize=8, which='major', pad=0)\n",
    "logo.ax.xaxis.set_tick_params(labelsize=0, which='minor', pad=0)\n",
    "logo.ax.xaxis.set_major_locator(plt.MultipleLocator(1))\n",
    "logo.ax.set_title(\"CDR1 Logo\", fontsize=18)\n",
    "# Save the figure as a PDF file\n",
    "logo_fig = logo.fig\n",
    "logo_fig.savefig('Logos/CDR1_logo.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b060afe",
   "metadata": {},
   "outputs": [],
   "source": [
    "#for outputting every logo in the folder\n",
    "import os\n",
    "import logomaker\n",
    "from Bio import AlignIO\n",
    "directory = \"Clusters\"\n",
    "logos_folder = \"Logos\"\n",
    "if not os.path.exists(logos_folder):\n",
    "    os.makedirs(logos_folder)\n",
    "\n",
    "# Get a list of .fa files in the directory\n",
    "fa_files = [file for file in os.listdir(directory) if file.startswith(\"cdr\") and file.endswith(\".fa\")]\n",
    "\n",
    "# Process each .fa file\n",
    "for fa_file in fa_files:\n",
    "    # Extract the varying part of the file name\n",
    "    varying_part = fa_file[len(\"cdr1_alignment_\"):-len(\".fa\")]\n",
    "\n",
    "    # Read in the alignment file in FASTA format\n",
    "    alignment = AlignIO.read(os.path.join(directory, fa_file), \"fasta\")\n",
    "\n",
    "    # Convert the alignment to a list of sequences\n",
    "    sequences = [str(record.seq) for record in alignment]\n",
    "\n",
    "    # Convert the sequences to a pandas dataframe\n",
    "    alignment_df = logomaker.alignment_to_matrix(sequences)\n",
    "\n",
    "    # Create the sequence logo\n",
    "    logo = logomaker.Logo(alignment_df, color_scheme='dmslogo_funcgroup')\n",
    "    # Customize the logo appearance\n",
    "    logo.style_spines(visible=False)\n",
    "    logo.ax.xaxis.set_tick_params(labelsize=8, which='major', pad=0)\n",
    "    logo.ax.xaxis.set_tick_params(labelsize=0, which='minor', pad=0)\n",
    "    logo.ax.xaxis.set_major_locator(plt.MultipleLocator(1))\n",
    "    logo.ax.set_title(fa_file, fontsize=18)\n",
    "\n",
    "\n",
    "    # Generate the output file name based on the varying part of the input file name\n",
    "    output_file = os.path.join(logos_folder, f\"logo_{varying_part}.png\")\n",
    "\n",
    "    # Save the figure as a PNG file\n",
    "    logo_fig = logo.fig\n",
    "    logo_fig.savefig(output_file, dpi=300)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34256b55",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(cdr_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "683e768a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "df = cdr_df\n",
    "\n",
    "parallel_df = pd.DataFrame({'CDR1 Seq': df['CDR1 Seq'],'CDR2 Seq':df['CDR2 Seq'], 'CDR3 Seq':df['CDR3 Seq'],'KD': df['KD']})\n",
    "\n",
    "split_seqs = parallel_df['CDR1 Seq'].apply(list).apply(pd.Series)\n",
    "split_seqs.columns = [f'CDR1.{i+1}' for i in range(split_seqs.shape[1])]\n",
    "\n",
    "\n",
    "cdr2_seqs = parallel_df['CDR2 Seq'].apply(list).apply(pd.Series)\n",
    "cdr2_seqs = cdr2_seqs.fillna('Del')\n",
    "cdr2_seqs.columns = [f'CDR2.{i+1}' for i in range(cdr2_seqs.shape[1])]\n",
    "\n",
    "cdr3_seqs = parallel_df['CDR3 Seq'].apply(list).apply(pd.Series)\n",
    "cdr3_seqs = cdr3_seqs.fillna('Del')\n",
    "cdr3_seqs.columns = [f'CDR3.{i+1}' for i in range(cdr3_seqs.shape[1])]\n",
    "\n",
    "split_seqs = pd.concat([split_seqs, cdr2_seqs], axis=1)\n",
    "split_seqs = pd.concat([split_seqs, cdr3_seqs], axis=1)\n",
    "split_seqs = split_seqs.fillna('Del')\n",
    "\n",
    "# Define a dictionary to map amino acids to numeric codes\n",
    "amino_acid_codes = {\n",
    "    'R': 1,\n",
    "    'H': 2,\n",
    "    'K': 3,\n",
    "    'Del': 4,\n",
    "    'A': 5,\n",
    "    'V': 6,\n",
    "    'I': 7,\n",
    "    'L': 8,\n",
    "    'M': 9,\n",
    "    'F': 10,\n",
    "    'Y': 11,\n",
    "    'W': 12,\n",
    "    'S': 13,\n",
    "    'T': 14,\n",
    "    'N': 15,\n",
    "    'Q': 16,\n",
    "    'C': 17,\n",
    "    'G': 18,\n",
    "    'P': 19,\n",
    "    'E': 20,\n",
    "    'D': 21\n",
    "}\n",
    "\n",
    "# Convert amino acids to numeric codes\n",
    "split_seqs = split_seqs.replace(amino_acid_codes)\n",
    "\n",
    "split_seqs = split_seqs.assign(KD=cdr_df['KD'])\n",
    "\n",
    "MinKD= min(cdr_df['KD'])\n",
    "MaxKD= max(cdr_df['KD'])\n",
    "print(\"Minimum KD \")\n",
    "print(MinKD)\n",
    "print(\"Maximum KD \")\n",
    "print(MaxKD)\n",
    "split_seqs = split_seqs.assign(Cluster=cdr_df['Cluster'])\n",
    "MaxClusters= max(cdr_df['Cluster'])\n",
    "MinClusters= min(cdr_df['Cluster'])\n",
    "print(\"Number of Clusters Found\")\n",
    "print(abs(MaxClusters-MinClusters)+1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98cf0b89",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import plotly.offline as pyo\n",
    "import plotly.graph_objs as go\n",
    "import plotly\n",
    "from plotly.offline import init_notebook_mode, iplot\n",
    "\n",
    "init_notebook_mode(connected=True)\n",
    "\n",
    "amino_acids = ['R', 'H', 'K', 'DEL', 'A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W', 'S', 'T', 'N', 'Q', 'C', 'G', 'P', 'E', 'D']\n",
    "\n",
    "dimensions = []\n",
    "\n",
    "for col in split_seqs.columns:  #this works with any number of CDR residue numbers\n",
    "    if col.startswith('CDR'):\n",
    "        dimension = dict(range=[1, 21],\n",
    "                         label=col,\n",
    "                         values=split_seqs[col],\n",
    "                         tickvals=list(range(1, 22)),\n",
    "                         ticktext=amino_acids)\n",
    "        dimensions.append(dimension)\n",
    "    if col.startswith('KD'):\n",
    "        KD_dimension = dict(range=[MinKD,MaxKD],\n",
    "                        label=col,\n",
    "                         values=split_seqs[col])\n",
    "        dimensions.append(KD_dimension)\n",
    "    if col.startswith('Cluster'):\n",
    "        KD_dimension = dict(range=[MinClusters,MaxClusters],\n",
    "                        label=col,\n",
    "                         values=split_seqs[col])\n",
    "        dimensions.append(KD_dimension)\n",
    "fig = go.Figure(data=go.Parcoords(\n",
    "    line=dict(color=split_seqs['CDR1.1'],\n",
    "              colorscale='Jet',\n",
    "              showscale=False,\n",
    "              cmin=1,\n",
    "              cmax=21),\n",
    "    dimensions=dimensions\n",
    "))\n",
    "\n",
    "fig.update_layout(\n",
    "    title=\"Hit sdAb CDR Sequences\",\n",
    "    width=2100,\n",
    "    height=600,\n",
    "    font=dict(size=14)\n",
    ")\n",
    "plotly.io.write_html(fig, include_plotlyjs=True, file='Output_Files/parallel_coordinates_plot.html')\n",
    "pyo.iplot(fig, filename='Output_Files/parallel_coordinates_plot.html')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27c7f45e",
   "metadata": {},
   "outputs": [],
   "source": [
    "cdr_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de29a017",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(split_seqs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "429a4e67",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import plotly.offline as pyo\n",
    "import plotly.graph_objs as go\n",
    "import plotly\n",
    "import dash\n",
    "import dash_core_components as dcc\n",
    "import dash_html_components as html\n",
    "from dash.dependencies import Input, Output, State\n",
    "import os\n",
    "\n",
    "\n",
    "\n",
    "amino_acids = ['R', 'H', 'K', 'DEL', 'A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W', 'S', 'T', 'N', 'Q', 'C', 'G', 'P', 'E', 'D']\n",
    "\n",
    "dimensions = []\n",
    "\n",
    "for col in split_seqs.columns:\n",
    "    if col.startswith('CDR'):\n",
    "        dimension = dict(range=[1, 21],\n",
    "                         label=col,\n",
    "                         values=split_seqs[col],\n",
    "                         tickvals=list(range(1, 22)),\n",
    "                         ticktext=amino_acids)\n",
    "        dimensions.append(dimension)\n",
    "    elif col.startswith('KD'):\n",
    "        KD_dimension = dict(range=[MinKD, MaxKD],\n",
    "                            label=col,\n",
    "                            values=split_seqs[col])\n",
    "        dimensions.append(KD_dimension)\n",
    "    elif col.startswith('Cluster'):\n",
    "        Cluster_dimension = dict(range=[MinClusters, MaxClusters],\n",
    "                                label=col,\n",
    "                                values=split_seqs[col])\n",
    "        dimensions.append(Cluster_dimension)\n",
    "\n",
    "fig = go.Figure(data=go.Parcoords(\n",
    "    line=dict(color='blue',\n",
    "              colorscale='Jet',\n",
    "              showscale=False,\n",
    "              cmin=1,\n",
    "              cmax=21),\n",
    "    dimensions=dimensions\n",
    "))\n",
    "\n",
    "fig.update_layout(\n",
    "    title=\"Hit sdAb CDR Sequences\",\n",
    "    width=1900,\n",
    "    height=600,\n",
    "    font=dict(size=14)\n",
    ")\n",
    "\n",
    "print(os.getcwd())\n",
    "\n",
    "app = dash.Dash(__name__)\n",
    "\n",
    "app.layout = html.Div([\n",
    "    dcc.Graph(id='parallel-coordinates-plot', figure=fig),\n",
    "    html.Button('Export to Excel', id='export-button'),\n",
    "])\n",
    "\n",
    "@app.callback(Output('export-button', 'download'), \n",
    "              [Input('export-button', 'n_clicks'), \n",
    "               Input('parallel-coordinates-plot', 'selectedData')],\n",
    "              [State('parallel-coordinates-plot', 'data')])\n",
    "def export_to_excel(n_clicks, selected_data, parallel_coordinates_data):\n",
    "    print('n_clicks:', n_clicks)\n",
    "    print(os.getcwd())\n",
    "    if n_clicks is not None and selected_data is not None:\n",
    "        selected_lines = selected_data['lines']\n",
    "        selected_indices = []\n",
    "        for line in selected_lines:\n",
    "            selected_indices.extend(line['pointIndex'])\n",
    "        \n",
    "        split_seqs = pd.DataFrame(parallel_coordinates_data['dimensions'][0]['values'])\n",
    "        selected_rows = split_seqs.iloc[selected_indices]\n",
    "        print('Number of selected rows:', len(selected_rows))\n",
    "        selected_rows.to_csv('selected_lines.csv', index=False)\n",
    "        print(\"Selected rows exported\")\n",
    "        return 'selected_lines.xlsx'\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    app.run_server()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86f3e8eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#this works, just has the future warning - whole thing for vox\n",
    "import matplotlib.pyplot as plt\n",
    "import Levenshtein as lev\n",
    "from matplotlib.pyplot import figure\n",
    "from sklearn.cluster import DBSCAN\n",
    "from Levenshtein import distance\n",
    "from scipy.spatial.distance import cdist\n",
    "import numpy as np\n",
    "from distributed import Client\n",
    "client = Client()\n",
    "import modin.pandas as pd\n",
    "# Define the framework sequences\n",
    "frameworks = {\n",
    "    'Framework1': 'LSCAAS',  #original value  'LSCAAS'\n",
    "    'Framework2': 'GWYRQAPGKER', #original value 'GWYRQAPGKER'\n",
    "    'Framework3': 'ADSVKGRFTISRDNAKNTVYLQMNSLKPEDTAVYYC',  #original value 'ADSVKGRFTISRDNAKNTVYLQMNSLKPEDTAVYYC'\n",
    "    'Framework4': 'YWGQG',     #original value 'YWGQG'\n",
    "}\n",
    "\n",
    "# Define the CDR loop positions relative to the framework sequences\n",
    "cdr_positions = {\n",
    "    'CDR1': ['Framework1', 'Framework2'],\n",
    "    'CDR2': ['Framework2', 'Framework3'], \n",
    "    'CDR3': ['Framework3', 'Framework4'],\n",
    "}\n",
    "\n",
    "# Load the data from the CSV file\n",
    "print(\"Reading CSV\")\n",
    "df = pd.read_csv('NSG_miseq_F_top200.csv')\n",
    "print(\"Starting Number of sequences \", len(df))\n",
    "print(\"Deleting sequences that do not contain one of the intended frameworks\")\n",
    "strings_to_check = {'LSCAAS', 'GWYRQAPGKER', 'ADSVKGRFTISRDNAKNTVYLQMNSLKPEDTAVYYC', 'YWGQG'}\n",
    "df['Sequence'] = df['Sequence'].str.strip()\n",
    "print(\"Remaining Sequences \",len(df))\n",
    "# Remove lines containing the asterisk character\n",
    "print(\"Removing sequences with stop codons\")\n",
    "df = df[~df.astype(str).apply(lambda x: x.str.contains('\\\\*')).any(axis=1)]\n",
    "print(\"Remaining Sequences \",len(df))\n",
    "# Check if all strings in `strings_to_check` are present in the 'Sequence' column\n",
    "df = df[df['Sequence'].apply(lambda x: all(string in x for string in strings_to_check))]\n",
    "print(\"Assigning random numbers to the KD column- Only use this if you have no TITE-seq values\")\n",
    "df['KD'] = np.random.randint(1, 1001, size=len(df))\n",
    "print(df)\n",
    "# Extract the CDR loop sequences\n",
    "print(\"Extracting CDR Loops\")\n",
    "cdr_seqs = {}\n",
    "\n",
    "# Loop over cdrs only once\n",
    "for cdr, positions in cdr_positions.items():\n",
    "    start_framework, end_framework = positions\n",
    "    # Use a lambda function to extract the CDR sequences\n",
    "    df[f'{cdr} Seq'] = df['Sequence'].apply(lambda x: x[x.find(frameworks[start_framework])+len(frameworks[start_framework]):x.find(frameworks[end_framework])])\n",
    "\n",
    "# Calculate the frequency of each CDR sequence and map these frequencies to the corresponding Seq column\n",
    "for cdr in cdr_positions.keys():\n",
    "    cdr_freqs = (df[f'{cdr} Seq'].value_counts(normalize=True)* 100)\n",
    "    df[f'{cdr} Freq'] = df[f'{cdr} Seq'].map(cdr_freqs)\n",
    "\n",
    "print(\"printing df after cdr seqs\")\n",
    "print(df)\n",
    "# Calculate the frequency percentage of each CDR sequence as a percentage\n",
    "cdr_freqs = {}\n",
    "print(\"Calculating CDR Frequencies\")\n",
    "for cdr in cdr_seqs:\n",
    "    cdr_count = len(cdr_seqs[cdr])\n",
    "    cdr_seq_array = np.array(cdr_seqs[cdr])\n",
    "    unique_seqs, counts = np.unique(cdr_seq_array, return_counts=True)\n",
    "    cdr_freqs[cdr] = (counts / cdr_count)*100\n",
    "print(\"CDR FREQs loop result\")\n",
    "print(cdr_freqs)\n",
    "print(\"Printing df after cdr freqs\")\n",
    "print(df)\n",
    "# Find the most common CDR sequence for each loop\n",
    "cdr_consensus_seqs = {}\n",
    "print(\"Identifying the most common CDR sequences for each loop\")\n",
    "for cdr in cdr_seqs:\n",
    "    cdr_freq_array = np.array(cdr_freqs[cdr])\n",
    "    max_freq_idx = np.argmax(cdr_freq_array)\n",
    "    cdr_consensus_seqs[cdr] = cdr_seqs[cdr][max_freq_idx]\n",
    "print(\"Printing freq array\")\n",
    "print(cdr_freq_array)\n",
    "print(\"Consensus seq loop result\")\n",
    "print(cdr_consensus_seqs)\n",
    "# Calculate the Levenshtein distance between each CDR sequence and the consensus sequence\n",
    "print(\"Calculating Levenshtein distance between each CDR and the most common CDR\")\n",
    "cdr_distances = {}\n",
    "for cdr in cdr_seqs:\n",
    "    cdr_distances[cdr] = [lev.distance(seq, cdr_consensus_seqs[cdr]) for seq in cdr_seqs[cdr]]\n",
    "print(\"Distance from consensus CDR result:\")\n",
    "print(cdr_distances)\n",
    "# Create a new dataframe with the results, removing duplicate sequences\n",
    "print(\"Combining data to a single dataframe\")\n",
    "\n",
    "cdr_df = pd.DataFrame()\n",
    "min_length = min(len(df), len(cdr_seqs['CDR1']), len(cdr_freqs['CDR1']), len(cdr_distances['CDR1']), len(cdr_seqs['CDR2']), len(cdr_freqs['CDR2']), len(cdr_distances['CDR2']), len(cdr_seqs['CDR3']), len(cdr_freqs['CDR3']), len(cdr_distances['CDR3']))\n",
    "for i in range(min_length):\n",
    "    cdr_df = pd.concat([cdr_df, pd.DataFrame({'Sequence': df['Sequence'].iloc[i],\n",
    "                                       'KD': df['KD'].iloc[i],\n",
    "                                       'CDR1 Seq': cdr_seqs['CDR1'][i],\n",
    "                                       'CDR1 Freq': cdr_freqs['CDR1'][i],\n",
    "                                       'CDR1 Distance': cdr_distances['CDR1'][i],\n",
    "                                       'CDR2 Seq': cdr_seqs['CDR2'][i],\n",
    "                                       'CDR2 Freq': cdr_freqs['CDR2'][i],\n",
    "                                       'CDR2 Distance': cdr_distances['CDR2'][i],\n",
    "                                       'CDR3 Seq': cdr_seqs['CDR3'][i],\n",
    "                                       'CDR3 Freq': cdr_freqs['CDR3'][i],\n",
    "                                       'CDR3 Distance': cdr_distances['CDR3'][i]}, index=[i])],\n",
    "                        ignore_index=True)\n",
    "\n",
    "print(\"Number of sequences after CDR1, CDR2, and CDR3 Extraction \", len(cdr_df) )\n",
    "print(cdr_df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b59d5e81",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ANACONDA3\\lib\\site-packages\\distributed\\node.py:161: UserWarning: Port 8787 is already in use.\n",
      "Perhaps you already have a cluster running?\n",
      "Hosting the HTTP server on port 59411 instead\n",
      "  f\"Port {expected} is already in use.\\n\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading CSV\n",
      "Starting Number of sequences  582750\n",
      "Deleting sequences that do not contain one of the intended frameworks\n",
      "Remaining Sequences  582750\n",
      "Removing sequences with stop codons\n",
      "Remaining Sequences  433936\n",
      "Assigning random numbers to the KD column- Only use this if you have no TITE-seq values\n",
      "Extracting CDR Loops\n",
      "Calculating losses in percentage on each step\n",
      "                     Step   Count Percent of Initial\n",
      "0                   Start  582750              100.0\n",
      "1       1 Framework Check  582750              100.0\n",
      "2    Removing Stop Codons  433936          74.463492\n",
      "3     All Framework Check  406621          69.776233\n",
      "4  Framework Length Check  404635          69.435435\n",
      "writing df to csv\n",
      "Graphing loss of sequences from filtering\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Completed\n"
     ]
    }
   ],
   "source": [
    "#this works, just has the future warning this is the latesworkingone\n",
    "import matplotlib.pyplot as plt\n",
    "import Levenshtein as lev\n",
    "from matplotlib.pyplot import figure\n",
    "from sklearn.cluster import DBSCAN\n",
    "from Levenshtein import distance\n",
    "from scipy.spatial.distance import cdist\n",
    "import numpy as np\n",
    "from distributed import Client\n",
    "client = Client()\n",
    "import pandas as pd\n",
    "# Define the framework sequences\n",
    "frameworks = {\n",
    "    'Framework1': 'LSCAAS',  #original value  'LSCAAS'\n",
    "    'Framework2': 'GWYRQAPGKER', #original value 'GWYRQAPGKER'\n",
    "    'Framework3': 'ADSVKGRFTISRDNAKNTVYLQMNSLKPEDTAVYYC',  #original value 'ADSVKGRFTISRDNAKNTVYLQMNSLKPEDTAVYYC'\n",
    "    'Framework4': 'YWGQG',     #original value 'YWGQG'\n",
    "}\n",
    "\n",
    "# Define the CDR loop positions relative to the framework sequences\n",
    "cdr_positions = {\n",
    "    'CDR1': ['Framework1', 'Framework2'],\n",
    "    'CDR2': ['Framework2', 'Framework3'], \n",
    "    'CDR3': ['Framework3', 'Framework4'],\n",
    "}\n",
    "\n",
    "# Load the data from the CSV file\n",
    "print(\"Reading CSV\")\n",
    "df = pd.read_csv('NSG_miseq_F.csv')\n",
    "print(\"Starting Number of sequences \", len(df))\n",
    "# Initialize an empty DataFrame\n",
    "counts_df = pd.DataFrame(columns=['Step', 'Count'])\n",
    "\n",
    "# Add a row to the DataFrame after each step in your code\n",
    "counts_df = counts_df.append({'Step': 'Start', 'Count': len(df)}, ignore_index=True)\n",
    "\n",
    "print(\"Deleting sequences that do not contain one of the intended frameworks\")\n",
    "strings_to_check = {'LSCAAS', 'GWYRQAPGKER', 'ADSVKGRFTISRDNAKNTVYLQMNSLKPEDTAVYYC', 'YWGQG'}\n",
    "df['Sequence'] = df['Sequence'].str.strip()\n",
    "print(\"Remaining Sequences \",len(df))\n",
    "counts_df = counts_df.append({'Step': '1 Framework Check', 'Count': len(df)}, ignore_index=True)\n",
    "# Remove lines containing the asterisk character\n",
    "print(\"Removing sequences with stop codons\")\n",
    "df = df[~df.astype(str).apply(lambda x: x.str.contains('\\\\*')).any(axis=1)]\n",
    "print(\"Remaining Sequences \",len(df))\n",
    "counts_df = counts_df.append({'Step': 'Removing Stop Codons', 'Count': len(df)}, ignore_index=True)\n",
    "# Check if all strings in `strings_to_check` are present in the 'Sequence' column\n",
    "df = df[df['Sequence'].apply(lambda x: all(string in x for string in strings_to_check))]\n",
    "counts_df = counts_df.append({'Step': 'All Framework Check', 'Count': len(df)}, ignore_index=True)\n",
    "print(\"Assigning random numbers to the KD column- Only use this if you have no TITE-seq values\")\n",
    "df['KD'] = np.random.randint(1, 10001, size=len(df))\n",
    "\n",
    "# Extract the CDR loop sequences\n",
    "print(\"Extracting CDR Loops\")\n",
    "cdr_seqs = {}\n",
    "\n",
    "# Loop over cdrs only once\n",
    "for cdr, positions in cdr_positions.items():\n",
    "    start_framework, end_framework = positions\n",
    "    # Use a lambda function to extract the CDR sequences\n",
    "    df[f'{cdr} Seq'] = df['Sequence'].apply(lambda x: x[x.find(frameworks[start_framework])+len(frameworks[start_framework]):x.find(frameworks[end_framework])])\n",
    "#filter out CDRs that are too long or too short\n",
    "# Set the lower and upper limits for the sequence lengths\n",
    "limits = {\n",
    "    'CDR1 Seq': {'lower': 8, 'upper': 10},\n",
    "    'CDR2 Seq': {'lower': 12, 'upper': 15},\n",
    "    'CDR3 Seq': {'lower': 8, 'upper': 22},\n",
    "}\n",
    "\n",
    "# Apply the conditions to each CDR column\n",
    "for cdr, lim in limits.items():\n",
    "    df = df[df[cdr].str.len().between(lim['lower'], lim['upper'])]\n",
    "\n",
    "counts_df = counts_df.append({'Step': 'Framework Length Check', 'Count': len(df)}, ignore_index=True)\n",
    "df['CDR1 Length'] = df['CDR1 Seq'].str.len()\n",
    "df['CDR2 Length'] = df['CDR2 Seq'].str.len()\n",
    "df['CDR3 Length'] = df['CDR3 Seq'].str.len()\n",
    "\n",
    "# Calculate the frequency of each CDR sequence and map these frequencies to the corresponding Seq column\n",
    "for cdr in cdr_positions.keys():\n",
    "    cdr_freqs = (df[f'{cdr} Seq'].value_counts(normalize=True)* 100)\n",
    "    df[f'{cdr} Freq'] = df[f'{cdr} Seq'].map(cdr_freqs)\n",
    "print(\"Calculating losses in percentage on each step\")\n",
    "counts_df['Percent of Initial'] = ((counts_df['Count'] / counts_df['Count'][0])* 100)\n",
    "print(counts_df)\n",
    "print(\"writing df to csv\")\n",
    "df.to_csv('output_seq_freq_CDRs.csv', index=False)\n",
    "print(\"Graphing loss of sequences from filtering\")\n",
    "ax = counts_df.plot(kind='bar', x='Step', y='Count', title='Number of Sequences After Different Filters')\n",
    "plt.xlabel('Step')\n",
    "plt.ylabel('Count')\n",
    "\n",
    "# Add the count values above the bars\n",
    "for i in range(len(counts_df)):\n",
    "    plt.text(i, counts_df['Count'].iloc[i], counts_df['Count'].iloc[i], ha = 'center')  # Add 0.5 to the y coordinate\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "print(\"Completed\")\n",
    "client.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "6c34aefc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AVLETRSYSFR    100.0\n",
       "Name: CDR3 Seq, dtype: float64"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4e220a4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Step</th>\n",
       "      <th>Count</th>\n",
       "      <th>Percent of Initial</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Start</td>\n",
       "      <td>582750</td>\n",
       "      <td>100.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1 Framework Check</td>\n",
       "      <td>582750</td>\n",
       "      <td>100.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Removing Stop Codons</td>\n",
       "      <td>433936</td>\n",
       "      <td>74.463492</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>All Framework Check</td>\n",
       "      <td>406621</td>\n",
       "      <td>69.776233</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Framework Length Check</td>\n",
       "      <td>404635</td>\n",
       "      <td>69.435435</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Step   Count Percent of Initial\n",
       "0                   Start  582750              100.0\n",
       "1       1 Framework Check  582750              100.0\n",
       "2    Removing Stop Codons  433936          74.463492\n",
       "3     All Framework Check  406621          69.776233\n",
       "4  Framework Length Check  404635          69.435435"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts_df['Percent of Initial'] = ((counts_df['Count'] / counts_df['Count'][0])* 100)\n",
    "counts_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "52d8f761",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "# Assuming df1, df2, df3 are DataFrames for each CDR\n",
    "# and 'length' is the column in these DataFrames that represents the length\n",
    "\n",
    "sns.histplot(df['CDR1 Length'], bins=15, color='blue', label='CDR1')\n",
    "sns.histplot(df['CDR2 Length'], bins=15, color='red', label='CDR2')\n",
    "sns.histplot(df['CDR3 Length'], bins=15, color='green', label='CDR3')\n",
    "\n",
    "\n",
    "plt.title('Distribution of CDR Lengths')\n",
    "plt.xlabel('Length of CDR')\n",
    "plt.ylabel('Count')\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "597ec883",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating Lev Distances for CDR1\n",
      "Completed\n",
      "Calculating Lev Distances for CDR2\n",
      "Completed\n",
      "Calculating Lev Distances for CDR3\n",
      "Completed\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from Levenshtein import distance\n",
    "\n",
    "# Assuming df is your DataFrame and 'CDR' is the column with the sequences\n",
    "print(\"Calculating Lev Distances for CDR1\")\n",
    "# Step 1: Calculate Levenshtein distance for unique sequences\n",
    "unique_sequences = df['CDR1 Seq'].unique()\n",
    "most_common_sequence = df['CDR1 Seq'].value_counts().idxmax()\n",
    "\n",
    "lev_distances = {seq: distance(most_common_sequence, seq) for seq in unique_sequences}\n",
    "\n",
    "# Step 2: Map distances back to all sequences\n",
    "df['CDR1 Distance'] = df['CDR1 Seq'].map(lev_distances)\n",
    "print(\"Completed\")\n",
    "print(\"Calculating Lev Distances for CDR2\")\n",
    "# Step 1: Calculate Levenshtein distance for unique sequences\n",
    "unique_sequences = df['CDR2 Seq'].unique()\n",
    "most_common_sequence = df['CDR2 Seq'].value_counts().idxmax()\n",
    "\n",
    "lev_distances = {seq: distance(most_common_sequence, seq) for seq in unique_sequences}\n",
    "\n",
    "# Step 2: Map distances back to all sequences\n",
    "df['CDR2 Distance'] = df['CDR2 Seq'].map(lev_distances)\n",
    "print(\"Completed\")\n",
    "print(\"Calculating Lev Distances for CDR3\")\n",
    "# Step 1: Calculate Levenshtein distance for unique sequences\n",
    "unique_sequences = df['CDR3 Seq'].unique()\n",
    "most_common_sequence = df['CDR3 Seq'].value_counts().idxmax()\n",
    "\n",
    "lev_distances = {seq: distance(most_common_sequence, seq) for seq in unique_sequences}\n",
    "\n",
    "# Step 2: Map distances back to all sequences\n",
    "df['CDR3 Distance'] = df['CDR3 Seq'].map(lev_distances)\n",
    "print(\"Completed\")\n",
    "import seaborn as sns\n",
    "\n",
    "# Assuming df1, df2, df3 are DataFrames for each CDR\n",
    "# and 'length' is the column in these DataFrames that represents the length\n",
    "\n",
    "sns.histplot(df['CDR1 Distance'], bins=11, color='blue', label='CDR1')\n",
    "sns.histplot(df['CDR2 Distance'], bins=15, color='red', label='CDR2')\n",
    "sns.histplot(df['CDR3 Distance'], bins=19, color='green', label='CDR3')\n",
    "\n",
    "\n",
    "plt.title('Distribution of CDR Lev Distances from Most Common Sequence')\n",
    "plt.xlabel('Lev Distance of CDR to Most Common Sequence')\n",
    "plt.ylabel('Count')\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "906e4916",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vectorizing CDR sequences\n",
      "Performing DBscan Clustering\n",
      "Completed Clustering\n",
      "Mapping back to df\n",
      "clustering Done\n",
      "Performing DBscan Clustering on CDR2\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\1\\ipykernel_24096\\457798529.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     25\u001b[0m \u001b[1;31m# Step 2: Perform DBSCAN clustering\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     26\u001b[0m \u001b[0mdbscan\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mDBSCAN\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0meps\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0.5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmin_samples\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 27\u001b[1;33m \u001b[0mdbscan\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     28\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Completed Clustering on CDR2\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     29\u001b[0m \u001b[1;31m# Step 3: Create a dictionary mapping sequences to cluster labels\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\cluster\\_dbscan.py\u001b[0m in \u001b[0;36mfit\u001b[1;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[0;32m    373\u001b[0m         \u001b[0mneighbors_model\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    374\u001b[0m         \u001b[1;31m# This has worst case O(n^2) memory complexity\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 375\u001b[1;33m         \u001b[0mneighborhoods\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mneighbors_model\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mradius_neighbors\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mreturn_distance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    376\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    377\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0msample_weight\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\neighbors\\_base.py\u001b[0m in \u001b[0;36mradius_neighbors\u001b[1;34m(self, X, radius, return_distance, sort_results)\u001b[0m\n\u001b[0;32m   1082\u001b[0m                 \u001b[0mresults\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mneigh_dist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mneigh_ind\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1083\u001b[0m             \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1084\u001b[1;33m                 \u001b[0mneigh_ind_list\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mchunked_results\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1085\u001b[0m                 \u001b[0mresults\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_to_object_array\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mneigh_ind_list\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1086\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\metrics\\pairwise.py\u001b[0m in \u001b[0;36mpairwise_distances_chunked\u001b[1;34m(X, Y, reduce_func, metric, n_jobs, working_memory, **kwds)\u001b[0m\n\u001b[0;32m   1715\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1716\u001b[0m             \u001b[0mX_chunk\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0msl\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1717\u001b[1;33m         \u001b[0mD_chunk\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpairwise_distances\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_chunk\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mY\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmetric\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mn_jobs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1718\u001b[0m         if (X is Y or Y is None) and PAIRWISE_DISTANCE_FUNCTIONS.get(\n\u001b[0;32m   1719\u001b[0m             \u001b[0mmetric\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\metrics\\pairwise.py\u001b[0m in \u001b[0;36mpairwise_distances\u001b[1;34m(X, Y, metric, n_jobs, force_all_finite, **kwds)\u001b[0m\n\u001b[0;32m   1887\u001b[0m         \u001b[0mfunc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpartial\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdistance\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcdist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmetric\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1888\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1889\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0m_parallel_pairwise\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mY\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1890\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1891\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\metrics\\pairwise.py\u001b[0m in \u001b[0;36m_parallel_pairwise\u001b[1;34m(X, Y, func, n_jobs, **kwds)\u001b[0m\n\u001b[0;32m   1428\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1429\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0meffective_n_jobs\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn_jobs\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1430\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mY\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1431\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1432\u001b[0m     \u001b[1;31m# enforce a threading backend to prevent data communication overhead\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\metrics\\pairwise.py\u001b[0m in \u001b[0;36meuclidean_distances\u001b[1;34m(X, Y, Y_norm_squared, squared, X_norm_squared)\u001b[0m\n\u001b[0;32m    328\u001b[0m             )\n\u001b[0;32m    329\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 330\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0m_euclidean_distances\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mY\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX_norm_squared\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mY_norm_squared\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msquared\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    331\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    332\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\metrics\\pairwise.py\u001b[0m in \u001b[0;36m_euclidean_distances\u001b[1;34m(X, Y, X_norm_squared, Y_norm_squared, squared)\u001b[0m\n\u001b[0;32m    369\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    370\u001b[0m         \u001b[1;31m# if dtype is already float64, no need to chunk and upcast\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 371\u001b[1;33m         \u001b[0mdistances\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m2\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0msafe_sparse_dot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mY\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdense_output\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    372\u001b[0m         \u001b[0mdistances\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mXX\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    373\u001b[0m         \u001b[0mdistances\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mYY\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\utils\\extmath.py\u001b[0m in \u001b[0;36msafe_sparse_dot\u001b[1;34m(a, b, dense_output)\u001b[0m\n\u001b[0;32m    159\u001b[0m         \u001b[1;32mand\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mret\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"toarray\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    160\u001b[0m     ):\n\u001b[1;32m--> 161\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mret\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtoarray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    162\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mret\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    163\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\scipy\\sparse\\compressed.py\u001b[0m in \u001b[0;36mtoarray\u001b[1;34m(self, order, out)\u001b[0m\n\u001b[0;32m   1048\u001b[0m             \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1049\u001b[0m         \u001b[0mM\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mN\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_swap\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1050\u001b[1;33m         \u001b[0mcsr_todense\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mM\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mN\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindptr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindices\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1051\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1052\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "from sklearn.cluster import DBSCAN\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "print(\"Vectorizing CDR sequences\")\n",
    "# Step 1: Convert sequences into k-mer frequency vectors\n",
    "vectorizer = CountVectorizer(analyzer='char', ngram_range=(2, 2))  # 2-mer frequencies\n",
    "unique_sequences = df['CDR1 Seq'].unique()\n",
    "X = vectorizer.fit_transform(unique_sequences)\n",
    "print(\"Performing DBscan Clustering\")\n",
    "# Step 2: Perform DBSCAN clustering\n",
    "dbscan = DBSCAN(eps=0.5, min_samples=5)\n",
    "dbscan.fit(X)\n",
    "print(\"Completed Clustering\")\n",
    "# Step 3: Create a dictionary mapping sequences to cluster labels\n",
    "print(\"Mapping back to df\")\n",
    "seq_cluster_dict = {seq: label for seq, label in zip(unique_sequences, dbscan.labels_)}\n",
    "\n",
    "# Map cluster labels back to original DataFrame\n",
    "df['CDR1 Cluster'] = df['CDR1 Seq'].map(seq_cluster_dict)\n",
    "print(\"clustering Done\")\n",
    "\n",
    "\n",
    "unique_sequences = df['CDR2 Seq']\n",
    "X = vectorizer.fit_transform(unique_sequences)\n",
    "print(\"Performing DBscan Clustering on CDR2\")\n",
    "# Step 2: Perform DBSCAN clustering\n",
    "dbscan = DBSCAN(eps=0.5, min_samples=5)\n",
    "dbscan.fit(X)\n",
    "print(\"Completed Clustering on CDR2\")\n",
    "# Step 3: Create a dictionary mapping sequences to cluster labels\n",
    "print(\"Mapping back to df\")\n",
    "seq_cluster_dict = {seq: label for seq, label in zip(unique_sequences, dbscan.labels_)}\n",
    "# Map cluster labels back to original DataFrame\n",
    "df['CDR2 Cluster'] = df['CDR2 Seq'].map(seq_cluster_dict)\n",
    "print(\"clustering Done\")\n",
    "\n",
    "\n",
    "unique_sequences = df['CDR3 Seq'].unique()\n",
    "X = vectorizer.fit_transform(unique_sequences)\n",
    "print(\"Performing DBscan Clustering on CDR3\")\n",
    "# Step 2: Perform DBSCAN clustering\n",
    "dbscan = DBSCAN(eps=0.5, min_samples=5)\n",
    "dbscan.fit(X)\n",
    "print(\"Completed Clustering on CDR3\")\n",
    "# Step 3: Create a dictionary mapping sequences to cluster labels\n",
    "print(\"Mapping back to df\")\n",
    "seq_cluster_dict = {seq: label for seq, label in zip(unique_sequences, dbscan.labels_)}\n",
    "# Map cluster labels back to original DataFrame\n",
    "df['CDR3 Cluster'] = df['CDR3 Seq'].map(seq_cluster_dict)\n",
    "print(\"clustering Done\")\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "print(df)\n",
    "sns.histplot(df['CDR1 Cluster'], bins=10, color='blue', label='CDR1')\n",
    "sns.histplot(df['CDR2 Cluster'], bins=10, color='red', label='CDR2')\n",
    "sns.histplot(df['CDR3 Cluster'], bins=10, color='green', label='CDR3')\n",
    "plt.title('Distribution of Cluster Assignments')\n",
    "plt.xlabel('Cluster')\n",
    "plt.ylabel('Count')\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6d3c1e0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clustering Initialized\n",
      "Fitting  CDR1\n"
     ]
    },
    {
     "ename": "MemoryError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mMemoryError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\1\\ipykernel_24096\\4012881797.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Fitting \"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mcdr\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m     \u001b[1;31m# Fit the model\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m     \u001b[0mdbscan\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdistances\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     11\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Fitting \"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mcdr\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\" Completed\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m     \u001b[1;31m# Assign the labels (cluster IDs) to a new column in the DataFrame\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\cluster\\_dbscan.py\u001b[0m in \u001b[0;36mfit\u001b[1;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[0;32m    373\u001b[0m         \u001b[0mneighbors_model\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    374\u001b[0m         \u001b[1;31m# This has worst case O(n^2) memory complexity\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 375\u001b[1;33m         \u001b[0mneighborhoods\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mneighbors_model\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mradius_neighbors\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mreturn_distance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    376\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    377\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0msample_weight\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\neighbors\\_base.py\u001b[0m in \u001b[0;36mradius_neighbors\u001b[1;34m(self, X, radius, return_distance, sort_results)\u001b[0m\n\u001b[0;32m   1116\u001b[0m                     \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_tree\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mradius\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mreturn_distance\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msort_results\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0msort_results\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1117\u001b[0m                 )\n\u001b[1;32m-> 1118\u001b[1;33m                 \u001b[1;32mfor\u001b[0m \u001b[0ms\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mgen_even_slices\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1119\u001b[0m             )\n\u001b[0;32m   1120\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mreturn_distance\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\joblib\\parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, iterable)\u001b[0m\n\u001b[0;32m   1041\u001b[0m             \u001b[1;31m# remaining jobs.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1042\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_iterating\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1043\u001b[1;33m             \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdispatch_one_batch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1044\u001b[0m                 \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_iterating\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_original_iterator\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1045\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\joblib\\parallel.py\u001b[0m in \u001b[0;36mdispatch_one_batch\u001b[1;34m(self, iterator)\u001b[0m\n\u001b[0;32m    859\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    860\u001b[0m             \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 861\u001b[1;33m                 \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_dispatch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtasks\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    862\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    863\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\joblib\\parallel.py\u001b[0m in \u001b[0;36m_dispatch\u001b[1;34m(self, batch)\u001b[0m\n\u001b[0;32m    777\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    778\u001b[0m             \u001b[0mjob_idx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_jobs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 779\u001b[1;33m             \u001b[0mjob\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapply_async\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mcb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    780\u001b[0m             \u001b[1;31m# A job can complete so quickly than its callback is\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    781\u001b[0m             \u001b[1;31m# called before we get here, causing self._jobs to\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\joblib\\_parallel_backends.py\u001b[0m in \u001b[0;36mapply_async\u001b[1;34m(self, func, callback)\u001b[0m\n\u001b[0;32m    206\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mapply_async\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    207\u001b[0m         \u001b[1;34m\"\"\"Schedule a func to be run\"\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 208\u001b[1;33m         \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mImmediateResult\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    209\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mcallback\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    210\u001b[0m             \u001b[0mcallback\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\joblib\\_parallel_backends.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, batch)\u001b[0m\n\u001b[0;32m    570\u001b[0m         \u001b[1;31m# Don't delay the application, to avoid keeping the input\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    571\u001b[0m         \u001b[1;31m# arguments in memory\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 572\u001b[1;33m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mresults\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mbatch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    573\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    574\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\joblib\\parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    261\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mparallel_backend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_n_jobs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    262\u001b[0m             return [func(*args, **kwargs)\n\u001b[1;32m--> 263\u001b[1;33m                     for func, args, kwargs in self.items]\n\u001b[0m\u001b[0;32m    264\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    265\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__reduce__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\joblib\\parallel.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m    261\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mparallel_backend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_n_jobs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    262\u001b[0m             return [func(*args, **kwargs)\n\u001b[1;32m--> 263\u001b[1;33m                     for func, args, kwargs in self.items]\n\u001b[0m\u001b[0;32m    264\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    265\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__reduce__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\utils\\fixes.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m    214\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    215\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mconfig_context\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 216\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfunction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    217\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    218\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\sklearn\\neighbors\\_base.py\u001b[0m in \u001b[0;36m_tree_query_radius_parallel_helper\u001b[1;34m(tree, *args, **kwargs)\u001b[0m\n\u001b[0;32m    911\u001b[0m     \u001b[0mcloudpickle\u001b[0m \u001b[0munder\u001b[0m \u001b[0mPyPy\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    912\u001b[0m     \"\"\"\n\u001b[1;32m--> 913\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0mtree\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mquery_radius\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    914\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    915\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32msklearn\\neighbors\\_binary_tree.pxi\u001b[0m in \u001b[0;36msklearn.neighbors._kd_tree.BinaryTree.query_radius\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32msklearn\\neighbors\\_binary_tree.pxi\u001b[0m in \u001b[0;36msklearn.neighbors._kd_tree.BinaryTree.query_radius\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mMemoryError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Create a new DBSCAN object\n",
    "dbscan = DBSCAN(eps=0.5, min_samples=5)\n",
    "print(\"Clustering Initialized\")\n",
    "# Loop over cdrs\n",
    "for cdr in cdr_positions.keys():\n",
    "    # Reshape the data to 2D (necessary for the fit method)\n",
    "    distances = df[f'{cdr} Distance'].values.reshape(-1, 1)\n",
    "    print(\"Fitting \",cdr)\n",
    "    # Fit the model\n",
    "    dbscan.fit(distances)\n",
    "    print(\"Fitting \",cdr,\" Completed\")\n",
    "    # Assign the labels (cluster IDs) to a new column in the DataFrame\n",
    "    print(\"Adding cluster labels to df\")\n",
    "    df[f'{cdr} Cluster'] = dbscan.labels_\n",
    "    print(\"Labels added for \",cdr)\n",
    "from Bio import SeqIO\n",
    "from Bio.Seq import Seq\n",
    "from Bio.SeqRecord import SeqRecord\n",
    "from Bio.Align import MultipleSeqAlignment\n",
    "\n",
    "# Define cdrs\n",
    "cdrs = ['CDR1', 'CDR2', 'CDR3']\n",
    "\n",
    "# Loop over cdrs\n",
    "for cdr in cdrs:\n",
    "    # Group sequences by cluster\n",
    "    groups = df.groupby(f'{cdr} Cluster')\n",
    "    for cluster, group in groups:\n",
    "        # Group sequences by length\n",
    "        length_groups = group.groupby(group[f'{cdr} Seq'].str.len())\n",
    "        for length, length_group in length_groups:\n",
    "            # Create a list of SeqRecord objects\n",
    "            seq_records = []\n",
    "            for i, seq in enumerate(length_group[f'{cdr} Seq']):\n",
    "                seq_record = SeqRecord(Seq(seq), id=f'seq{i+1}')\n",
    "                seq_records.append(seq_record)\n",
    "\n",
    "            # Align the sequences\n",
    "            alignment = MultipleSeqAlignment(seq_records)\n",
    "\n",
    "            # Write the aligned sequences to a file in FASTA format\n",
    "            with open(f'Clusters/{cdr}_alignment_{cluster}_length_{length}.fa', 'w') as f:\n",
    "                SeqIO.write(alignment, f, 'fasta')\n",
    "    print(f\"{cdr} Cluster sequence alignment completed\")\n",
    "#for outputting every logo in the folder\n",
    "import os\n",
    "import logomaker\n",
    "from Bio import AlignIO\n",
    "directory = \"Clusters\"\n",
    "logos_folder = \"Logos\"\n",
    "if not os.path.exists(logos_folder):\n",
    "    os.makedirs(logos_folder)\n",
    "\n",
    "# Get a list of .fa files in the directory\n",
    "fa_files = [file for file in os.listdir(directory) if file.startswith(\"CDR\") and file.endswith(\".fa\")]\n",
    "\n",
    "# Process each .fa file\n",
    "for fa_file in fa_files:\n",
    "    # Extract the varying part of the file name\n",
    "    varying_part = fa_file[len(\"cdr1_alignment_\"):-len(\".fa\")]\n",
    "\n",
    "    # Read in the alignment file in FASTA format\n",
    "    alignment = AlignIO.read(os.path.join(directory, fa_file), \"fasta\")\n",
    "\n",
    "    # Convert the alignment to a list of sequences\n",
    "    sequences = [str(record.seq) for record in alignment]\n",
    "\n",
    "    # Convert the sequences to a pandas dataframe\n",
    "    alignment_df = logomaker.alignment_to_matrix(sequences)\n",
    "\n",
    "    # Create the sequence logo\n",
    "    logo = logomaker.Logo(alignment_df, color_scheme='dmslogo_funcgroup')\n",
    "    # Customize the logo appearance\n",
    "    logo.style_spines(visible=False)\n",
    "    logo.ax.xaxis.set_tick_params(labelsize=8, which='major', pad=0)\n",
    "    logo.ax.xaxis.set_tick_params(labelsize=0, which='minor', pad=0)\n",
    "    logo.ax.xaxis.set_major_locator(plt.MultipleLocator(1))\n",
    "    logo.ax.set_title(fa_file, fontsize=18)\n",
    "\n",
    "\n",
    "    # Generate the output file name based on the varying part of the input file name\n",
    "    output_file = os.path.join(logos_folder, f\"{fa_file}_logo.png\")\n",
    "\n",
    "    # Save the figure as a PNG file\n",
    "    logo_fig = logo.fig\n",
    "    logo_fig.savefig(output_file, dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "d3ba3ee3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CDR1 Cluster sequence alignment completed\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'CDR2 Cluster'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\1\\ipykernel_24096\\152414537.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mcdr\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mcdrs\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m     \u001b[1;31m# Group sequences by cluster\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m     \u001b[0mgroups\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{cdr} Cluster'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     13\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mcluster\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgroup\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mgroups\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m         \u001b[1;31m# Group sequences by length\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\pandas\\core\\frame.py\u001b[0m in \u001b[0;36mgroupby\u001b[1;34m(self, by, axis, level, as_index, sort, group_keys, squeeze, observed, dropna)\u001b[0m\n\u001b[0;32m   7639\u001b[0m             \u001b[0msqueeze\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0msqueeze\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;31m# type: ignore[arg-type]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   7640\u001b[0m             \u001b[0mobserved\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mobserved\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 7641\u001b[1;33m             \u001b[0mdropna\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdropna\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   7642\u001b[0m         )\n\u001b[0;32m   7643\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\pandas\\core\\groupby\\groupby.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, obj, keys, axis, level, grouper, exclusions, selection, as_index, sort, group_keys, squeeze, observed, mutated, dropna)\u001b[0m\n\u001b[0;32m    895\u001b[0m                 \u001b[0mobserved\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mobserved\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    896\u001b[0m                 \u001b[0mmutated\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmutated\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 897\u001b[1;33m                 \u001b[0mdropna\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdropna\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    898\u001b[0m             )\n\u001b[0;32m    899\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\ANACONDA3\\lib\\site-packages\\pandas\\core\\groupby\\grouper.py\u001b[0m in \u001b[0;36mget_grouper\u001b[1;34m(obj, key, axis, level, sort, observed, mutated, validate, dropna)\u001b[0m\n\u001b[0;32m    860\u001b[0m                 \u001b[0min_axis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgpr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgpr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    861\u001b[0m             \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 862\u001b[1;33m                 \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    863\u001b[0m         \u001b[1;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgpr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mGrouper\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mgpr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkey\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    864\u001b[0m             \u001b[1;31m# Add key to exclusions\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: 'CDR2 Cluster'"
     ]
    }
   ],
   "source": [
    "from Bio import SeqIO\n",
    "from Bio.Seq import Seq\n",
    "from Bio.SeqRecord import SeqRecord\n",
    "from Bio.Align import MultipleSeqAlignment\n",
    "\n",
    "# Define cdrs\n",
    "cdrs = ['CDR1', 'CDR2', 'CDR3']\n",
    "\n",
    "# Loop over cdrs\n",
    "for cdr in cdrs:\n",
    "    # Group sequences by cluster\n",
    "    groups = df.groupby(f'{cdr} Cluster')\n",
    "    for cluster, group in groups:\n",
    "        # Group sequences by length\n",
    "        length_groups = group.groupby(group[f'{cdr} Seq'].str.len())\n",
    "        for length, length_group in length_groups:\n",
    "            # Create a list of SeqRecord objects\n",
    "            seq_records = []\n",
    "            for i, seq in enumerate(length_group[f'{cdr} Seq']):\n",
    "                seq_record = SeqRecord(Seq(seq), id=f'seq{i+1}')\n",
    "                seq_records.append(seq_record)\n",
    "\n",
    "            # Align the sequences\n",
    "            alignment = MultipleSeqAlignment(seq_records)\n",
    "\n",
    "            # Write the aligned sequences to a file in FASTA format\n",
    "            with open(f'Clusters/{cdr}_alignment_{cluster}_length_{length}.fa', 'w') as f:\n",
    "                SeqIO.write(alignment, f, 'fasta')\n",
    "    print(f\"{cdr} Cluster sequence alignment completed\")\n",
    "#for outputting every logo in the folder\n",
    "import os\n",
    "import logomaker\n",
    "from Bio import AlignIO\n",
    "directory = \"Clusters\"\n",
    "logos_folder = \"Logos\"\n",
    "if not os.path.exists(logos_folder):\n",
    "    os.makedirs(logos_folder)\n",
    "\n",
    "# Get a list of .fa files in the directory\n",
    "fa_files = [file for file in os.listdir(directory) if file.startswith(\"CDR\") and file.endswith(\".fa\")]\n",
    "\n",
    "# Process each .fa file\n",
    "for fa_file in fa_files:\n",
    "    # Extract the varying part of the file name\n",
    "    varying_part = fa_file[len(\"cdr1_alignment_\"):-len(\".fa\")]\n",
    "\n",
    "    # Read in the alignment file in FASTA format\n",
    "    alignment = AlignIO.read(os.path.join(directory, fa_file), \"fasta\")\n",
    "\n",
    "    # Convert the alignment to a list of sequences\n",
    "    sequences = [str(record.seq) for record in alignment]\n",
    "\n",
    "    # Convert the sequences to a pandas dataframe\n",
    "    alignment_df = logomaker.alignment_to_matrix(sequences)\n",
    "\n",
    "    # Create the sequence logo\n",
    "    logo = logomaker.Logo(alignment_df, color_scheme='dmslogo_funcgroup')\n",
    "    # Customize the logo appearance\n",
    "    logo.style_spines(visible=False)\n",
    "    logo.ax.xaxis.set_tick_params(labelsize=8, which='major', pad=0)\n",
    "    logo.ax.xaxis.set_tick_params(labelsize=0, which='minor', pad=0)\n",
    "    logo.ax.xaxis.set_major_locator(plt.MultipleLocator(1))\n",
    "    logo.ax.set_title(fa_file, fontsize=18)\n",
    "\n",
    "\n",
    "    # Generate the output file name based on the varying part of the input file name\n",
    "    output_file = os.path.join(logos_folder, f\"{fa_file}_logo.png\")\n",
    "\n",
    "    # Save the figure as a PNG file\n",
    "    logo_fig = logo.fig\n",
    "    logo_fig.savefig(output_file, dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d934016",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "941d11f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<built-in method keys of dict object at 0x0000024FA0BADB88>\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41fd80d0",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}