08.Modulo_8_serotipado.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Módulo 8: Serotipado *Streptococcus pneumoniae* y *Streptococcus agalactiae* \n",
    "\n",
    "## Descripción general\n",
    "\n",
    "Este módulo será desarrollado en dos partes:\n",
    "\n",
    "1. Parte 1: Prediciendo serotipos de *S. pneumoniae*\n",
    "\n",
    "2. Parte 2: Prediciendo serotipos de *S. agalactiae*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instalar condacolab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -q condacolab\n",
    "import condacolab\n",
    "condacolab.install()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instalar programas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Nota**: En este módulo utilizaremos SeroBA para la predicción de serotipos de *S. pneumoniae*. Sin embargo, el repositorio original de esta herramienta no tiene soporte actualmente. Por lo tanto, utilizaremos el repositorio de [Bentley-group](https://github.com/sanger-bentley-group/seroba) donde se recomienta el uso de la herramienta con Docker."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿Qué es Docker?\n",
    "\n",
    "[Docker](https://www.docker.com/) es una plataforma abierta para desarrollar, enviar y ejecutar aplicaciones. Proporciona la capacidad de empaquetar y ejecutar una aplicación en un entorno aislado llamado contenedor. Los contenedores son ligeros y contienen todo lo necesario para ejecutar la aplicación, por lo que no es necesario depender de lo que esté instalado en el sistema anfitrión; es decir, implica agrupar una aplicación junto con todos los archivos de configuración, bibliotecas y dependencias necesarios para asegurar que el software pueda ejecutarse de manera reproducible en una variedad de entornos de computación. Puede compartir fácilmente contenedores mientras trabajas y estar seguro de que todos con quienes los compartas obtendrán el mismo contenedor que funcionará de la misma manera. Aquí puede ver un diagrama de la arquitectura de docker:\n",
    "\n",
    "![docker](images/docker.png)\n",
    "\n",
    "*Tomado de: https://docs.docker.com/get-started/docker-overview/*\n",
    "\n",
    "Si desea profundizar en el funcionamiento de Docker y sus contenedores puede dirigirse a: https://docs.docker.com/get-started/introduction/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instalar udocker\n",
    "%shell\n",
    "!pip install udocker\n",
    "!udocker --allow-root install"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Obtener SeroBA\n",
    "!udocker --allow-root pull sangerbentleygroup/seroba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compruebe si se seroBA se instaló correctamente\n",
    "!udocker --allow-root run sangerbentleygroup/seroba seroba version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**Nota**: En este módulo utilizaremos srst2 para la predicción de serotipos de *S. agalactiae*. Sin embargo, esta herramienta no funciona adecuadamente en Python3. Por lo tanto, instalaremos Python2 y ejecutaremos la herramienta utilizando la versión python=2.7 con los comandos `!conda run -n py2_env`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crear un ambiente en conda con la version 2.7 de python. El ambiente se llamará python2 \n",
    "!conda create -n py2_env python=2.7\n",
    "#!apt-get install python2\n",
    "!conda run -n py2_env python --version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Instalar srst2\n",
    "!conda run -n py2_env conda install -c bioconda srst2 --yes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compruebe si se srst2 se instaló correctamente\n",
    "!conda run -n py2_env srst2 --help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Descargar datos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://zenodo.org/records/14231070/files/Module_8.tar.gz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extraer el archivo .tar.gz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!tar xvf Module_8.tar.gz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parte 1: Prediciendo serotipos de *S. pneumoniae*\n",
    "\n",
    "Hasta la fecha, hay más de 100 serotipos conocidos descritos para *S. pneumoniae* según las diferentes propiedades bioquímicas y antigénicas de la cápsula. Hay una serie de métodos in-silico para detectar el locus cps, que luego se pueden utilizar para predecir serotipos a partir de datos WGS. La identificación precisa de los serotipos neumocócicos es importante para rastrear la distribución y evolución de los serotipos luego de la introducción de vacunas efectivas.\n",
    "\n",
    "Se desarrolló [SeroBA](https://github.com/sanger-pathogens/seroba?tab=readme-ov-file#installation), el cual hace un uso eficiente de los recursos computacionales además de detectar con precisión el locus cps en baja cobertura y predice serotipos a partir de datos WGS utilizando una base de datos adaptada de PneumoCaT. SeroBA puede predecir serotipos mediante la identificación del locus cps, directamente a partir de datos de lectura de secuenciación del genoma completo sin procesar con un 98 % de concordancia utilizando un método basado en k-mer, puede procesar 10 000 muestras en poco más de 1 día utilizando un servidor estándar y puede llamar serotipos en una cobertura tan baja como 10x. SeroBA está implementado en Python3 y está disponible gratuitamente bajo una licencia GPLv3 de código abierto.\n",
    "\n",
    "*Lectura adicional*: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC6113868/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explore el uso de serobar ejecutando ``seroba -h``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ejecutar seroBA\n",
    "!udocker --allow-root run sangerbentleygroup/seroba seroba --help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SeroBA requiere solo tres archivos de entrada:\n",
    "\n",
    "1. Base de datos con kmc (utilidad diseñada para contar k-mers) y ariba (identificación de resistencia antimicrobiana por ensamblaje).\n",
    "\n",
    "Para este módulo usaremos la base de datos `seroba_k71_14082017` que se encuentra en la carpeta del módulo.\n",
    "\n",
    " Si desea crear la base de datos ud mismo en su ordenador, puede seguir los pasos que se encuentran [aquí](https://github.com/sanger-pathogens/seroba?tab=readme-ov-file#setting-up-the-database).\n",
    "\n",
    "2. Archivos de secuencias forward y reverse en fastq.\n",
    "\n",
    "Utilizaremos los archivos pareados ERR331173_1.fastq.gz y ERR331173_2.fastq.gz los cuales corresponden al run accession ERR331173 del proyecto [PRJEB3084](https://www.ebi.ac.uk/ena/browser/view/PRJEB3084).\n",
    "\n",
    "Algunos datos importantes de la muestra:\n",
    "\n",
    "- País de origen: Perú\n",
    "- Organismo: *Streptococcus pneumoniae*\n",
    "- Instrumento: ILLUMINA\n",
    "- Modelo del instrumento: Illumina MiSeq \n",
    "- Conteo de reads: 1203646\n",
    "- Conteo de bases: 240729200 \n",
    "- Nombre del centro: Wellcome Sanger Institute;SC \n",
    "- Diseño de librerías:  PAIRED\n",
    "- Estrategia de librerías: WGS\n",
    "\n",
    "3. Prefijo de salida."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Para predecir el serotipo de una sola cepa , usaremos el comando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correr Seroba con udocker\n",
    "!udocker --allow-root run -v /content/Module_8/seroba_k71_14082017:/seroba_k71_14082017 -v /content/Module_8:/fastq_files sangerbentleygroup/seroba seroba runSerotyping /seroba_k71_14082017 /fastq_files/ERR1795461_1.fastq.gz /fastq_files/ERR1795461_2.fastq.gz /fastq_files/output_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una explicación de este comando es la siguiente:\n",
    "\n",
    "`udocker` Es una herramienta que permite ejecutar contenedores Docker sin necesitar privilegios de administrador (root). Está diseñada para entornos en los que no se puede instalar Docker directamente, como en sistemas compartidos o de computación en la nube, donde los usuarios no tienen permisos de root.\n",
    "\n",
    "`--allow-root`  Esta opción le permite a udocker ejecutarse como superusuario (root). Normalmente, udocker está diseñado para funcionar sin privilegios elevados, pero con esta opción se permite que sea ejecutado por el usuario root.\n",
    "\n",
    "`-v`  Esta opción se usa para montar volúmenes entre el host y el contenedor. Esto permite que los archivos en la carpeta del host estén accesibles dentro del contenedor, facilitando el intercambio de datos entre el host y el contenedor.\n",
    "\n",
    "`run` es una función para iniciar un contenedor\n",
    "\n",
    "`sangerbentleygroup/seroba` es la imagen acoplable [sangerbentleygroup - representa el repositorio y seroba - representa la imagen del contenedor]\n",
    "\n",
    "`seroba` es la herramienta/programa\n",
    "\n",
    "`runSerotyping` especifica que el programa realizará la serotipificación\n",
    "\n",
    "`seroba_k71_14082017` especifica dónde está el directorio de seroba\n",
    "\n",
    "`ERR331173_1.fastq.gz` y `ERR331173_2.fastq.gz` son los archivos fastq de avance y retroceso\n",
    "\n",
    "`ERR331173_output` especifica el prefijo de salida"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la carpeta de salida, encontrará un **pred.tsv** que incluye su serotipo predicho."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predecir el serotipo de múltiples cepas\n",
    "\n",
    ">**Nota:** En este módulo no ejecutaremos el serotipado múltiple por la falta de recursos en Colab. Sin embargo, aquí tienes un ejemplo de como hacerlo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Primero crearemos una carpeta para cada par de archivos FASTQ comprimidos y el nombre de la identificación de la cepa usando el comando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# No ejecutar\n",
    "# Mover archivos\n",
    "# for x in *1.fastq.gz; do mkdir ${x%%_1.fastq.gz} ; mv $x ${x%%_1.fastq.gz}; mv ${x%%1.fastq.gz}2.fastq.gz ${x%%_1.fastq.gz}; done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una explicación de este comando es la siguiente:\n",
    "\n",
    "`for x en 1.fastq.gz;` Esto inicia un ciclo for que itera sobre todos los archivos en el directorio actual que terminan con \"1.fastq.gz\".\n",
    "\n",
    "`do` Esto inicia el bloque de código que se ejecutará para cada archivo.\n",
    "\n",
    "`mkdir ${x%%_1.fastq.gz}` Esto crea un nuevo directorio con el mismo nombre que el archivo, pero con el sufijo \"_1.fastq.gz\" eliminado.\n",
    "\n",
    "`mv $x ${x%%_1.fastq.gz}` Esto mueve el archivo original al nuevo directorio creado en el paso anterior.\n",
    "\n",
    "`mv ${x%%1.fastq.gz}2.fastq.gz ${x%%_1.fastq.gz}` Esto mueve un segundo archivo que tiene el mismo prefijo que el primer archivo, pero con un \"2.fastq sufijo .gz\", en el nuevo directorio creado en el primer paso.\n",
    "\n",
    "`done` Esto finaliza el bucle for.\n",
    "\n",
    "En general, este script está diseñado para tomar datos de secuenciación pareados que se almacenan en dos archivos separados con nombres que terminan en \"_1.fastq.gz\" y \"_2.fastq.gz\", y organizarlos en directorios según el prefijo de los nombres de archivo.\n",
    "\n",
    "*Lectura adicional sobre los comandos de bucle*: https://www.gnu.org/software/bash/manual/bash.html#Looping-Constructs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Después ejecutaremos seroBA usando el comando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# No ejecutar\n",
    "# Correr seroBA en un loop\n",
    "#for x in * ; do seroba runSerotyping seroba_k71_14082017 $x/${x}_1.fastq.gz $x/${x}_2.fastq.gz $x\"_output\"; done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una explicación de este comando es la siguiente:\n",
    "\n",
    "`for x in *;` Esto inicia un ciclo for que itera sobre todos los archivos en el directorio actual.\n",
    "`do` Esto inicia el bloque de código que se ejecutará para cada archivo.\n",
    "\n",
    "`seroba runSerotyping seroba_k71_14082017` Esto ejecuta el comando \"runSerotyping\" dentro del contenedor Docker, usando la base de datos \"seroba_k71_14082017\".\n",
    "\n",
    "`$x/${x}_1.fastq.gz $x/${x}_2.fastq.gz` Estos son los archivos de entrada para el comando, ubicados en un directorio con el nombre del archivo (sin el carácter \"#\") y con \"_1.fastq.gz\" o \"_2.fastq.gz\" añadido al nombre.\n",
    "\n",
    "`$x\"_output\"` Este es el directorio de salida para el comando, también nombrado después del archivo (con \"_output\" añadido al nombre).\n",
    "\n",
    "`;` Esto separa el comando Docker del final del bucle for.\n",
    "\n",
    "`done` Esto finaliza el bucle for."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finalmente compilaremos los resultados de las ejecuciones anteriores con el comando:\n",
    "\n",
    "Este comando combinará las salidas de seroba en un archivo tsv."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# No ejecutar\n",
    "# Resumen de los resultados\n",
    "#!seroba summary ./"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parte 2: Prediciendo serotipos de *S. agalactiae*\n",
    "\n",
    "*Streptococcus agalactiae* (*Streptococcus* del grupo B o GBS) se divide actualmente en diez serotipos según los antígenos capsulares específicos del tipo y se denominan Ia, Ib, II, III, IV, V, VI, VII, VIII y IX.\n",
    "\n",
    "Group B Streptococcus Serotyping by Genome Sequencing repository contiene un archivo de referencia seleccionado que se puede utilizar para serotipificar *Streptococcus agalactiae* *in silico* con datos de secuenciación del genoma completo. El archivo de referencia (GBS-SBG.fasta) está diseñado para que se pueda utilizar tanto para el mapeo de lectura corta como para las estrategias basadas en ensamblaje.\n",
    "\n",
    "*Lectura adicional*: https://github.com/swainechen/GBS-SBG\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El programa [SRST2](https://github.com/katholt/srst2 ) (Short Read Sequence Typing for Bacterial Pathogens) está diseñado para tomar datos de secuencias de Illumina, una base de datos MLST y/o una base de datos de secuencias de genes (por ejemplo, genes de resistencia, genes de virulencia, etc.) e informar la presencia de ST y/o genes de referencia. Este programa realiza una detección rápida y precisa de genes y alelos a partir de lecturas de secuenciación corta WGS. SRST2 puede tipicar lecturas utilizando cualquier base de datos de secuencias y puede calcular tipos de secuencias combinatorias definidas en bases de datos tipo MLST.\n",
    "\n",
    "*Lectura adicional*: https://genomemedicine.biomedcentral.com/articles/10.1186/s13073-014-0090-6\n",
    "\n",
    "### SRST2 requiere:\n",
    "\n",
    "1. lecturas pareadas: \n",
    "\n",
    "En esta sección analizaremos los datos pertenecientes al estudio [Near-term pregnant women in the Dominican Republic experience high rates of Group B Streptococcus rectovaginal colonization with virulent strains](https://doi.org/10.1371/journal.pgph.0002281) realizado por Laycock KM, Acosta F, Valera S, Villegas A, Mejia E, Mateo C, et al. (2023). Utilizaremos los archivos pareados FASTQ SRR23874884_1.fastq.gz y SRR23874884_2.fastq.gz los cuales corresponden al run accession SRR23874884 del proyecto [PRJNA945321](https://www.ebi.ac.uk/ena/browser/view/PRJNA945321)\t.\n",
    "\n",
    "Algunos datos importantes de la muestra:\n",
    "\n",
    "- País de origen: República Dominicana\n",
    "- Organismo: *Streptococcus agalactiae*\n",
    "- Instrumento: ILLUMINA\n",
    "- Modelo del instrumento: Illumina NovaSeq 6000  \n",
    "- Conteo de reads: 1916182\n",
    "- Conteo de bases: 578686964 \n",
    "- Nombre del centro: SUB12954699  \n",
    "- Diseño de librerías:  PAIRED\n",
    "- Estrategia de librerías: WGS\n",
    "\n",
    "2. Una base de datos de secuencias en un archivo fasta:\n",
    "\n",
    "GBS-SBG.fasta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Para predecir el serotipo de una sola cepa usaremos el comando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Primero nos dirigimos a la carpeta que contiene los datos de la Parte 2 del módulo\n",
    "%cd /content/Module_8/s_agalactiae/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correr srst2\n",
    "!conda run -n py2_env srst2 --input_pe SRR23874884_1.fastq.gz SRR23874884_2.fastq.gz --output SRR23874884 --log --gene_db GBS-SBG.fasta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una explicación de este comando es la siguiente:\n",
    "\n",
    "`conda` Es la herramienta de línea de comandos para gestionar entornos y paquetes en Conda, que es un sistema de gestión de paquetes y entornos.\n",
    "\n",
    "`run` Este subcomando de Conda se usa para ejecutar comandos dentro de un entorno Conda específico sin necesidad de activar el entorno primero.\n",
    "\n",
    "`-n py2_env`: La opción -n especifica el nombre del entorno Conda en el que se deben ejecutar los comandos. En este caso, py2_env es el nombre del entorno que hemos creado.\n",
    "\n",
    "`srst2` es la herramienta\n",
    "\n",
    "`--input_pe` especifica que el archivo de entrada son lecturas finales emparejadas que son SRR23874884_1.fastq.gz y SRR23874884_2.fastq.gz \n",
    "\n",
    "`--output `especifica el archivo de salida SRR23874884\n",
    "\n",
    "`--log` active el registro en el archivo, en lugar de la salida estándar\n",
    "\n",
    "`--gene_db` especifica la base de datos GBS-SBG.fasta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejecute el comando `ls -lh` para verificar el contenido de la carpeta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Listar archivos\n",
    "!ls -lh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El archivo de salida de la ejecución anterior es `SRR23874884__genes__GBS-SBG__results.txt`\n",
    "\n",
    "Entonces, ejecutaremos `cat` `SRR23874884__genes__GBS-SBG__results.txt` para ver el contenido de este archivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ver el contenido de un archivo\n",
    "!cat SRR23874884__genes__GBS-SBG__results.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Para ejecutar SRST2 en múltiples cepas, ejecute el comando:\n",
    "\n",
    ">**Nota:** En este módulo no ejecutaremos SRST2 múltiple por la falta de recursos en Colab. Sin embargo, aquí tiene un ejemplo de como hacerlo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# No ejecutar\n",
    "# Correr srst2 en un loop\n",
    "#!conda run -n py2_env srst2 --input_pe *.fastq.gz --output s.agalactiae --log --gene_db GBS-SBG.fasta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`--input_pe *.fastq.gz` especifica que el archivo de entrada son varios archivos fastq.gz comprimidos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BONO!\n",
    "\n",
    "Si está trabajando con BASH en su computadora o en un HPC y tiene demasiados archivos, puede optimizar los comandos, los bucles (for loops) son muy útiles para grandes conjuntos de datos.\n",
    "\n",
    "Aquí hay una manera de hacerlo.\n",
    "\n",
    "Cree un nuevo script bash usando nano llamado `serotype.sh`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/bin/bash\n",
    "#Nombre de archivo: Serotype.sh\n",
    "#Este script para serotipificar S.pneumoniae a partir de fastq.gz recortados\n",
    "\n",
    "function docker_run() { docker run --rm=True -u $(id -u):$(id -g) -v $(pwd):/data \"$@\" ;}\n",
    "wordir=/path/to/your/directory/\n",
    "cd $wordir\n",
    "\n",
    "for i in $(ls *_1.trimmed.fastq.gz); do\n",
    "\n",
    "NAME=$(basename $i _1.trimmed.fastq.gz)\n",
    "echo \"$NAME\"\n",
    "j=\"${NAME}_1.trimmed.fastq.gz\"\n",
    "echo \"$j\"\n",
    "k=\"${NAME}_2.trimmed.fastq.gz\"\n",
    "echo \"$k\"\n",
    "\n",
    "docker_run staphb/seroba seroba runSerotyping seroba_k71_14082017 ./$j ./$k ${NAME}_serotype_output;\n",
    "\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Movemos todas las salidas a una nueva carpeta  `mv *_serotype_output serotype_results`, luego compilamos todos los datos dentro del nuevo directorio con el comando `seroba summary ./`  debe obtener un archivo tsv."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cree un nuevo script bash usando nano llamado `serotype_2.sh`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/bin/bash\n",
    "#Este script para serotipificar múltiples lecturas genómicas de S. agalactaeae\n",
    "\n",
    "function docker_run() { docker run --rm=True -u $(id -u):$(id -g) -v $(pwd):/data \"$@\" ;}\n",
    "wordir=/path/to/your/directory/\n",
    "cd $wordir\n",
    "mkdir -p serotyping_output\n",
    "\n",
    "for i in $(ls *_1.fastq.gz); do\n",
    "\n",
    "NAME=$(basename $i _1.fastq.gz)\n",
    "echo \"$NAME\"\n",
    "j=\"${NAME}_1.fastq.gz\"\n",
    "echo \"$j\"\n",
    "k=\"${NAME}_2.fastq.gz\"\n",
    "echo \"$k\"\n",
    "\n",
    "docker_run staphb/srst2 srst2 --input_pe $j $k --output ./serotyping_out/${NAME}_output --log --gene_db analysis/clean_data/GBS-SBG.fasta;\n",
    "\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Adaptado de:*\n",
    "\n",
    "- Advanced Bioinformatics Course developed for the GPS and JUNO projects - Wellcome Sanger Insitute\n",
    "    \n",
    "*Modificado por Luisa Sacristán (Universidad de los Andes-CABANA)*"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}