Notebooks/create_chimera.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shutil\n",
    "from Bio import SeqIO\n",
    "import os\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#start from a genbank file of plasmid\n",
    "\n",
    "######################\n",
    "##    USER INPUT   ##\n",
    "#####################\n",
    "genbk = 'hM3R_hM4R_BS_pcDNA3.1(+).dna'\n",
    "\n",
    "os.mkdir(\"new_design\")\n",
    "os.chdir(\"./new_design/\")\n",
    "\n",
    "#retrieve in plasmid the dna sequence of chimera\n",
    "!gbseqextractor -f $genbk -prefix \"DNAseq_chimera\" -types wholeseq\n",
    "# convert dna to protein\n",
    "!Python conversion_DNA_prot.py -i DNAseq_chimera.fasta -o prot_chimera.fasta\n",
    "\n",
    "#retrieve chimera seq\n",
    "for record in SeqIO.parse(open(\"prot_chimera.fasta\"),\"fasta\"):\n",
    "    chimera_seq=record.seq\n",
    "    if chimera_seq[-1]==\"_\":\n",
    "        chimera_seq=chimera_seq[0:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MTLHNNSTTSPLFPNISSSWIHSPSDAGLPPGTVTHFGSYNVSRAAGNFSSPDGTTDDPLGGHTVWQVVFIAFLTGILALVTIIGNILVIVSFCFHLKSWKSNNYFLLSLACADLIIGVISMNLFTTYIIMNRWALGNLACDLWLAIDCVASNASVMNLLVISFDRYFSIVHPHHALNKISNRTAGVMIGLAWVISFVLWAPAILFWQYFVGKRTVPPGECFIQFLSEPTITFGTAIAGFYMPVTIMTILYWRIIWSLRQRQMDRHAKIKRAIQTLSAILLAFIITWTPYNIMVLVNTFCDSCIPKTFWNLGYWLCYINSTVNPVCYALCNKTFRNFFSTLINRCLQRKMTGEPDNNRSTSVELTGDPNKTRGAPEALMANSGEPWSPSYLGPTSP\n"
     ]
    }
   ],
   "source": [
    "#start from given sequence\n",
    "\n",
    "######################\n",
    "##    USER INPUT   ##\n",
    "#####################\n",
    "chimera_seq= \"MTLHNNSTTSPLFPNISSSWIHSPSDAGLPPGTVTHFGSYNVSRAAGNFSSPDGTTDDPLGGHTVWQVVFIAFLTGILALVTIIGNILVIVSFCFHLKSWKSNNYFLLSLACADLIIGVISMNLFTTYIIMNRWALGNLACDLWLAIDCVASNASVMNLLVISFDRYFSIVHPHHALNKISNRTAGVMIGLAWVISFVLWAPAILFWQYFVGKRTVPPGECFIQFLSEPTITFGTAIAGFYMPVTIMTILYWRIIWSLRQRQMDRHAKIKRAIQTLSAILLAFIITWTPYNIMVLVNTFCDSCIPKTFWNLGYWLCYINSTVNPVCYALCNKTFRNFFSTLINRCLQRKMTGEPDNNRSTSVELTGDPNKTRGAPEALMANSGEPWSPSYLGPTSP\"\n",
    "chimera_seq = chimera_seq.replace(' ','')\n",
    "print(chimera_seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from Bio.Blast import NCBIWWW\n",
    "import xml.etree.ElementTree as ET\n",
    "import requests, sys\n",
    "import json\n",
    "from Bio import pairwise2\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "# 2.Look for EC parent GPCR (longest sequence donor):\n",
    "result_handle = NCBIWWW.qblast(program=\"blastp\", database=\"swissprot\", sequence=chimera_seq, expect=\"0.01\",hitlist_size = 10)\n",
    "\n",
    "# 3.Create directory where all info will be stored. Will be renamed later with name chimera which is at this point still to be defined\n",
    "os.mkdir(\"new_design\")\n",
    "os.chdir(\"./new_design/\")\n",
    "\n",
    "# 4.Write blastp results. First hit will be considered as EC parent GPCR\n",
    "with open(\"reference_parent.xml\", \"w\") as out_handle:\n",
    "    out_handle.write(result_handle.read())\n",
    "\n",
    "# 5. Read from blastp results the uniprot id of the EC parent GPCR\n",
    "result_xml = open(\"reference_parent.xml\")\n",
    "tree = ET.parse(result_xml)\n",
    "root = tree.getroot()\n",
    "ref_id = root.find('.//Hit_id').text.split(\"|\")[1].split('.')[0]\n",
    "\n",
    "#Or directly define EC parent UniProt ID if you know it\n",
    "# ref_id = \"P20309\"\n",
    "\n",
    "# 6.Retrieve the entire sequence and name of the EC parent GPCR from uniprot\n",
    "requestURL = f\"https://rest.uniprot.org/uniprotkb/{ref_id}.json\"\n",
    "r = requests.get(requestURL, headers={ \"Accept\" : \"application/json\"})\n",
    "if not r.ok:\n",
    "  r.raise_for_status()\n",
    "  sys.exit()\n",
    "raw_data = r.text\n",
    "raw_data_ref = json.loads(raw_data)\n",
    "ref_seq = raw_data_ref[\"sequence\"][\"value\"]\n",
    "ref_name=raw_data_ref['uniProtkbId']\n",
    "\n",
    "# 7. Local alignment of the chimera and the EC parent GPCR\n",
    "alignments = pairwise2.align.localxx(chimera_seq, ref_seq)\n",
    "alignment = alignments[0]\n",
    "aligned_chimera = alignment.seqA\n",
    "aligned_ref = alignment.seqB\n",
    "\n",
    "# 8. Write the alignment in the \"new_design\" folder\n",
    "with open(\"alignment_chimera_reference.fasta\", \"w\") as align:\n",
    "  align.write(\">chimera \\n\")\n",
    "  align.write(aligned_chimera + \"\\n\")\n",
    "  align.write(f\">{ref_id} \\n\")\n",
    "  align.write(aligned_ref + \"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In the alignment_chimera_target.fasta file in the folder, identify the positions of these sections (parts from target GPCR) \n",
      "\n",
      "['', 'FCFHLKSWKS', 'VHPHHALNKISNRT', 'RIIWSLRQRQMDRHAKIKRAI', 'NFFSTLINRCLQRKMTGEPDNNRSTSVELTGDPNKTRGAPEALMANSGEPWSPSYLGPTSP']\n"
     ]
    }
   ],
   "source": [
    "from Bio import SeqIO\n",
    "\n",
    "# 9. Define the cutting points in the EC parent GPCR. \n",
    "# Open \"alignment_chimera_reference.fasta\" file and define the cutting points\n",
    "# Must be write like this: \n",
    "# if until residue 137 of the aligned chimera it is from the EC parent\n",
    "# if from 161 to 235 of the aligned chimera it is from the EC parent\n",
    "# if from 308 to 361 of the aligned chimera it is from the EC parent\n",
    "# write:\n",
    "# cutting_points_ref = {\"ref1\" : [1,137],\n",
    "#                  \"ref2\" : [161,235],\n",
    "#                  \"ref3\" : [308,361]}\n",
    "# The code will automatically convert the limits into python list limits (start counting at 0)\n",
    "# The code will automatically translate the aligned sequences to unaligned sequences\n",
    "######################\n",
    "##    USER INPUT   ##\n",
    "#####################\n",
    "\n",
    "cutting_points_ref = {\n",
    "                 \"ref1\" : [1,92],\n",
    "                 \"ref2\" : [110,177],\n",
    "                 \"ref3\" : [201,268],\n",
    "                 \"ref4\" : [510,571],}\n",
    "\n",
    "#this enables to take into account eventual corrections we do to the MSA\n",
    "for record in SeqIO.parse(open(\"alignment_chimera_reference.fasta\"),'fasta'):\n",
    "    if record.id == \"chimera\":\n",
    "        aligned_chimera = record.seq\n",
    "    else:\n",
    "        aligned_ref = record.seq\n",
    "\n",
    "# 10. Translate the cutting points limits into the unaligned positions of the EC parent\n",
    "previous = 0\n",
    "translate = []\n",
    "msa = aligned_ref\n",
    "sequence_nogaps = ref_seq\n",
    "for res in range(len(sequence_nogaps)):\n",
    "    couple = []\n",
    "    couple.append(res+1)\n",
    "    idx_msa = previous + msa[previous:].index(sequence_nogaps[res])\n",
    "    couple.append(idx_msa+1)\n",
    "    translate.append(couple)\n",
    "    previous = idx_msa + 1\n",
    "\n",
    "cutting_points_final_ref = {}\n",
    "for points in cutting_points_ref:\n",
    "    limits = cutting_points_ref[points]\n",
    "    lower = limits[0]\n",
    "    upper = limits[1]\n",
    "    for couple in translate:\n",
    "        if couple[1]==lower:\n",
    "            lower_translate = couple[0]\n",
    "        if couple[1]==upper:\n",
    "            upper_translate = couple[0]\n",
    "            break\n",
    "    cutting_points_final_ref[points]=[lower_translate,upper_translate] \n",
    "    #final cutting points in \"human\" format (if writte [150,224], take from residue 150 (included) to residue 224 (included))\n",
    "\n",
    "\n",
    "# 11.Translate cutting points in python format\n",
    "cutting_points_python = {}\n",
    "for point in cutting_points_ref:\n",
    "  limits = cutting_points_ref[point]\n",
    "  cutting_points_python[point]=[limits[0]-1,limits[1]] #because python starts counting at 0 and stops at upper limit - 1 for the lists\n",
    "\n",
    "# 12.Retrieve the parts of the chimera that are not from the EC parent GPCR\n",
    "parts_target = \"\"\n",
    "parts_target_list=[]\n",
    "keys = list(cutting_points_python.keys())\n",
    "if cutting_points_python[keys[0]][0] != 1: #means that the IC parent has actually been found not the EC parent\n",
    "    parts_list = \"\"\n",
    "    upper = cutting_points_python[keys[0]][0]\n",
    "    for residue in aligned_chimera[0:upper]:\n",
    "        if residue != \"-\":\n",
    "            parts_target+=residue\n",
    "            parts_list +=residue\n",
    "    parts_target_list.append(parts_list)\n",
    "#retrieve other parts\n",
    "for key in range(len(keys)-1):\n",
    "    parts_list = \"\"\n",
    "    upper = cutting_points_python[keys[key]][1]\n",
    "    next_lower = cutting_points_python[keys[key+1]][0]\n",
    "    for residue in aligned_chimera[upper:next_lower]:\n",
    "        if residue != \"-\":\n",
    "            parts_target+=residue\n",
    "            parts_list +=residue\n",
    "    parts_target_list.append(parts_list)\n",
    "\n",
    "next_upper= cutting_points_python[keys[-1]][1]\n",
    "parts_list = \"\"\n",
    "for residue in aligned_chimera[next_upper:]:\n",
    "    if residue != \"-\":\n",
    "        parts_target+=residue\n",
    "        parts_list +=residue\n",
    "parts_target_list.append(parts_list)\n",
    "\n",
    "print(\"In the alignment_chimera_target.fasta file in the folder, identify the positions of these sections (parts from IC parent GPCR) \\n\")\n",
    "print(parts_target_list)\n",
    "\n",
    "# 13.Run blastp again to find the IC parent GPCR\n",
    "result_handle = NCBIWWW.qblast(program=\"blastp\", database=\"swissprot\", sequence=parts_target, expect=\"0.01\",hitlist_size = 10)\n",
    "\n",
    "# 14.Write blastp results. First hit will be considered as IC parent GPCR\n",
    "with open(\"target_parent.xml\", \"w\") as out_handle:\n",
    "    out_handle.write(result_handle.read())\n",
    "\n",
    "# 15. Read from blastp results the uniprot id of the IC parent GPCR\n",
    "result_xml = open(\"target_parent.xml\")\n",
    "tree = ET.parse(result_xml)\n",
    "root = tree.getroot()\n",
    "target_id = root.find('.//Hit_id').text.split(\"|\")[1].split('.')[0]\n",
    "\n",
    "#Or directly define IC parent UniProt ID\n",
    "# target_id = \"Q8TDS4\"\n",
    "\n",
    "# 16.Retrieve the entire sequence and name of the IC parent GPCR from uniprot\n",
    "requestURL = f\"https://rest.uniprot.org/uniprotkb/{target_id}.json\"\n",
    "r = requests.get(requestURL, headers={ \"Accept\" : \"application/json\"})\n",
    "if not r.ok:\n",
    "  r.raise_for_status()\n",
    "  sys.exit()\n",
    "raw_data = r.text\n",
    "raw_data_target = json.loads(raw_data)\n",
    "target_seq = raw_data_target[\"sequence\"][\"value\"]\n",
    "target_name=raw_data_target['uniProtkbId']\n",
    "\n",
    "# 17. Local alignment of the chimera and the IC parent GPCR\n",
    "alignments = pairwise2.align.localxx(chimera_seq, target_seq)\n",
    "alignment = alignments[0]\n",
    "aligned_chimera = alignment.seqA\n",
    "aligned_target = alignment.seqB\n",
    "\n",
    "# 18. Write the alignment in the \"new_design\" folder\n",
    "with open(\"alignment_chimera_target.fasta\", \"w\") as align:\n",
    "  align.write(\">chimera \\n\")\n",
    "  align.write(aligned_chimera + \"\\n\")\n",
    "  align.write(f\">{target_id} \\n\")\n",
    "  align.write(aligned_target + \"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 19. Define the cutting points in the IC parent GPCR. \n",
    "# Open \"alignment_chimera_target.fasta\" file and define the cutting points\n",
    "# By looking up the regions printed out in the cell above\n",
    "# Must be write like this: \n",
    "# if from 217 to 229 of the aligned chimera it is from the IC parent\n",
    "# if from 351 to 405 of the aligned chimera it is from the IC parent\n",
    "# if from 489 to 579 of the aligned chimera it is from the IC parent\n",
    "# write:\n",
    "# cutting_points_target = {\"target1\" : [217,229],\n",
    "#                  \"target2\" : [351,405],\n",
    "#                  \"target3\" : [489,579]}\n",
    "# The code will automatically convert the limits into python list limits (start counting at 0)\n",
    "# The code will automatically translate the aligned sequences to unaligned sequences\n",
    "######################\n",
    "##    USER INPUT   ##\n",
    "#####################\n",
    "cutting_points_target = {\n",
    "                 \"target1\" : [120,129],\n",
    "                 \"target2\" : [238,251],\n",
    "                 \"target3\" : [361,381],\n",
    "                 \"target4\" : [492,552],}\n",
    "\n",
    "\n",
    "#this enables to take into account eventual corrections we do to the MSA\n",
    "for record in SeqIO.parse(open(\"alignment_chimera_target.fasta\"),'fasta'):\n",
    "    if record.id == \"chimera\":\n",
    "        aligned_chimera = record.seq\n",
    "    else:\n",
    "        aligned_target = record.seq\n",
    "\n",
    "# 20. Translate the cutting points limits into the unaligned positions of the IC parent\n",
    "previous = 0\n",
    "translate = []\n",
    "msa = aligned_target\n",
    "sequence_nogaps = target_seq\n",
    "for res in range(len(sequence_nogaps)):\n",
    "    couple = []\n",
    "    couple.append(res+1)\n",
    "    idx_msa = previous + msa[previous:].index(sequence_nogaps[res])\n",
    "    couple.append(idx_msa+1)\n",
    "    translate.append(couple)\n",
    "    previous = idx_msa + 1\n",
    "\n",
    "cutting_points_final_target = {}\n",
    "for points in cutting_points_target:\n",
    "    limits = cutting_points_target[points]\n",
    "    lower = limits[0]\n",
    "    upper = limits[1]\n",
    "    for couple in translate:\n",
    "        if couple[1]==lower:\n",
    "            lower_translate = couple[0]\n",
    "        if couple[1]==upper:\n",
    "            upper_translate = couple[0]\n",
    "            break\n",
    "    cutting_points_final_target[points]=[lower_translate,upper_translate] \n",
    "    #final cutting points in \"human\" format (if writte [150,224], take from residue 150 (included) to residue 224 (included))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #in case you need to switch between EC parent and IC parent\n",
    "# #names\n",
    "# temp = ref_name\n",
    "# ref_name = target_name\n",
    "# target_name = temp\n",
    "\n",
    "# #ids\n",
    "# temp = ref_id\n",
    "# ref_id = target_id\n",
    "# target_id = temp\n",
    "\n",
    "# #cutting points\n",
    "# temp = cutting_points_final_ref\n",
    "# cutting_points_final_ref = cutting_points_final_target\n",
    "# cutting_points_final_target = temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'ref1': [1, 92], 'target1': [52, 61], 'ref2': [103, 170], 'target2': [130, 143], 'ref3': [185, 252], 'target3': [210, 230], 'ref4': [491, 552], 'target4': [303, 363]}\n"
     ]
    }
   ],
   "source": [
    "#Create a fasta file for the chimera\n",
    "#put sequence that we entered and sequence created by assembling the 2 parents. \n",
    "#If they don't fit perfectly, then we made an error in the cutting points definition\n",
    "cutting = {}\n",
    "# Iterate over the keys of dict_a and dict_b simultaneously\n",
    "for key_ref, key_target in zip(cutting_points_final_ref.keys(),cutting_points_final_target.keys()):\n",
    "    cutting[key_ref] = cutting_points_final_ref[key_ref]\n",
    "    cutting[key_target] = cutting_points_final_target[key_target]\n",
    "\n",
    "# If dict_a and dict_b have different lengths, add the remaining elements from the longer dictionary\n",
    "remaining_keys = set(cutting_points_final_ref.keys()) ^ set(cutting_points_final_target.keys())  # Find the keys that are not present in both dictionaries\n",
    "\n",
    "for key in remaining_keys:\n",
    "    if key in cutting_points_final_ref:\n",
    "        cutting[key] = cutting_points_final_ref[key]\n",
    "    else:\n",
    "        cutting[key] = cutting_points_final_target[key]\n",
    "print(cutting)\n",
    "\n",
    "chimera_parts= []\n",
    "previous_len = 0\n",
    "novel_sequence=\"\" #compare the original given chimera sequence and the sequence that we can make with the found cutting points. The 2 sequences must match otherwise error in the cutting points\n",
    "for point in cutting.keys():\n",
    "    lower=cutting[point][0]\n",
    "    upper=cutting[point][1]\n",
    "    if \"ref\" in point:\n",
    "        novel_sequence+=ref_seq[lower-1:upper]\n",
    "    else:\n",
    "        novel_sequence+=target_seq[lower-1:upper]\n",
    "    chimera_parts.append([previous_len+1,len(novel_sequence)])\n",
    "    previous_len=len(novel_sequence) #to find what are the different parts in the chimera sequence\n",
    "\n",
    "with open(\"chimera.fasta\",\"w\") as f:\n",
    "    f.write(\">chimera\\n\")\n",
    "    f.write(str(chimera_seq) +\"\\n\")\n",
    "    f.write(\">Created with code \\n\")\n",
    "    f.write(novel_sequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 21.Write all info in excel file\n",
    "# Load the Excel file\n",
    "os.chdir(\"../../\")\n",
    "df = pd.read_excel('previous_designs.xlsx', sheet_name=\"GPCRs_A\")\n",
    "\n",
    "# Retrieve the 'Chimera_name' column data to check which chimera names have a\n",
    "already_designed_chimeras = list(df['Chimera_name'])\n",
    "\n",
    "chimera_name = ref_name + \"_\" + target_name + \"_\"\n",
    "counter = 1\n",
    "for entry in already_designed_chimeras:\n",
    "    if entry.startswith(chimera_name):\n",
    "        counter += 1\n",
    "chimera_name = chimera_name + str(counter)\n",
    "id_chimera_name = ref_id+\"_\"+target_id+ \"_\"+str(counter)\n",
    "already_designed_chimeras.append(chimera_name)\n",
    "\n",
    "# #Rename the folder with the name of the design\n",
    "# os.rename(\"./Found_designs/new_design/chimera.fasta\",\"./Found_designs/new_design/\"+chimera_name+\".fasta\")\n",
    "os.rename(\"./Found_designs/new_design\",\"./Found_designs/\"+chimera_name)\n",
    "\n",
    "new_row = {\n",
    "    'Chimera_name': chimera_name,\n",
    "    'Chimera_name_ids' : id_chimera_name,\n",
    "    'Chimera_parts':chimera_parts,\n",
    "    'Reference_name': ref_name,\n",
    "    'Reference_id': ref_id,\n",
    "    'Reference_cutting_points': cutting_points_final_ref,\n",
    "    'Target_name': target_name,\n",
    "    'Target_id': target_id,\n",
    "    'Target_cutting_points': cutting_points_final_target,\n",
    "    'Expression?': 'Yes',\n",
    "    'Function?': 'New function',\n",
    "    'Comments': 'Additional comments',\n",
    "    'Authors': '',\n",
    "    'DOI': ''\n",
    "}\n",
    "# Append the new row to the dataframe\n",
    "df_dictionary = pd.DataFrame([new_row])\n",
    "df = pd.concat([df, df_dictionary], ignore_index=True)\n",
    "\n",
    "df.to_excel('previous_designs.xlsx',sheet_name='GPCRs_A',index=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Y149C,A239G,\n"
     ]
    }
   ],
   "source": [
    "#Find mutated residues in chimera compared to parents\n",
    "#if print nothing then no mutations\n",
    "\n",
    "for record in SeqIO.parse(open(\"./Found_designs/\"+chimera_name+\"/chimera.fasta\"),\"fasta\"):\n",
    "    if \"Created\" in record.id:\n",
    "        novel_sequence = record.seq\n",
    "    else:\n",
    "        chimera_seq = record.seq\n",
    "\n",
    "pos=1\n",
    "mutated=\"\"\n",
    "for res_chimera, res_parents in zip(chimera_seq,novel_sequence):\n",
    "    if res_chimera != res_parents:\n",
    "        mutated+=f\"{res_parents}{pos}{res_chimera},\"\n",
    "    pos +=1\n",
    "print(mutated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "#remove the sequence that was added to the fasta file of the chimera to check if we found the correct cutting points\n",
    "for record in SeqIO.parse(open(\"./Found_designs/\"+chimera_name+\"/chimera.fasta\"),\"fasta\"):\n",
    "    seq = str(record.seq)\n",
    "    break\n",
    "with open(\"./Found_designs/\"+chimera_name+\"/\"+chimera_name+\".fasta\", \"w\") as f:\n",
    "    f.write(\">\"+chimera_name.replace('-','')+\"\\n\")\n",
    "    f.write(seq +\"\\n\")\n",
    "    \n",
    "os.remove(\"./Found_designs/\"+chimera_name+\"/chimera.fasta\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.10.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}