This is a project to practice getting and cleaning data in R and Python!
There are three notebooks for this project in the table of contents.

The goal behind this project is to collect data on genome sizes from various organisms on NCBI, generating a table that can be used to analyze which genome sizes (or mitchondrial genome sizes) are the largest (Part 1). I also decided to write some python scripts (Part 2) using the BioEntrez package to query Entrez on NCBI and collect taxonomy information for each organism to add to the table. Finally, I generated a local SQLite database to hold the BioEntrez taxonomy data, and then queried the database in R to add the new data to the dataframe (Part 3).

Part 1: Getting and cleaning data from genome assemblies statistics files

Setup

library(dplyr)
library(ggplot2)

Downloaded multiple text files containing the genome sizes of multiple organisms. The goal is to extract just the organism names, total genome length, and maybe mitochondrial genome length just for fun!

Here’s what the files look like:
Each file has an upper section that contains organism information such as scientific name and common name….

And a lower section containing genome size data:

The organism name and genome length data (we want the "Primary Assembly, total-length and ungapped-length lines) are in seperate parts of the file. We’ll need to extract and then combine them to be able to compare between organisms.

The first thing I tried was to get a table with the genome size with just one of the txt files.

assembliesR<-read.delim("~/ncbi-genomes-2019-05-19/GCF_900747795.1_fErpCal1.1_assembly_stats.txt",sep="",header=F,fill=TRUE,comment.char="#")
print(assembliesR[1:15,])

Ok, we have 6 columns containing the data we need, but the organism name isn’t listed because it’s # commented in the txt file.

After some testing, I decided to extract the genome size data and the organism name from the text files with two separate scripts…

Section 1: Organism Names

First, the names:

fdir<-list.files("~/ncbi-genomes-2019-05-19", 
                 pattern=".txt",full.names=T)
#450 files total
fdir<-(c(fdir[1:448])) #remove 449 and 450, empty files

Now I have a list of all the text files.

#Read the txt files, including # header containing names
assem.n<-lapply(fdir, function(i) {
  read.delim(i,
      sep=" ",
      header=F,
      fill=T,
      comment.char="")})
#Get name based on row locations.... !doesn't work for all files
get_name<- function(x){
  x[3,4:6]
}
#apply function to all files
N<- lapply(assem.n, get_name)

This extracts the names for some of the files, but not all…

print(N[4:12])

Need to find a way to extract based on the string preceding the organism name…

(Starting over)

assem.n<-lapply(fdir, function(i) {
  read.delim(i,
             sep=" ",
             header=F,
             fill=T,
             comment.char="") })

top_only<- function(x) '[' (x[1:20,])
assem.n<-lapply(assem.n,top_only)
cut_columns<- function(x) x[,2:7]
assem.n<-lapply(assem.n,cut_columns)

get_name<- function (x) '[' (x[which(x[,]=="Organism"),])
nn<-lapply(assem.n,get_name)

This works a lot better! Now nn can be converted to a data frame of organism names:


paste_species<- function(name_) {
  paste(name_$V5, name_$V6, sep=" ")
}
lnames<- lapply(nn,paste_species)
dfnames <- data.frame(matrix(unlist(lnames), nrow=length(lnames),
            byrow=T),stringsAsFactors=FALSE)
colnames(dfnames)<-"Organism"
head(dfnames)

It would be better to assign an ID to each organism name, so it can be linked to the data later…

lnames<- lapply(nn,paste_species)

lna<-rbind.data.frame((cbind(lnames)), make.row.names = F)
print(head(lna))
colnames(lna)<-"Organism"
lna2<-cbind("ID"=rownames(lna), lna)
#print(head(lna2))
#printing in the chunk doesn't seem to work here... this code works in console

#Check if ID column value matches the organism's original position
#in the list of assemblies files:
print(lna[448,])
print(nn[[448]])
print(assem.n[[448]])

Section 2: Genome data

This is a bit easier, since I can use the same function but exclude all of the commented text at the top, leaving just the data table at the bottom. Here’s the example again:

example<-read.delim("~/ncbi-genomes-2019-05-19/GCF_900747795.1_fErpCal1.1_assembly_stats.txt", sep="\t", col.names=colnames, comment.char="#")
print(example[1:15,])

Reading the data into R the same way as the names script, this time using comment character ‘#’ and assigning column names.

colnames<-c("unit_name","mol_name","mol_type","seq_type","stat","value")

assem.data<-lapply(fdir, function(i){
    read.delim(i,
      sep="\t",
      header=F,
      fill=T,
      comment.char="#",
      col.names=colnames)})

print(assem.data[[3]][1:10,])

Now, test extracting just the “Primary Assembly” rows with mol_name = all. Just use assem.data[[3]] to test.

subset(assem.data[[3]], unit_name=="Primary Assembly" & mol_name=="all")

Now, for file 3, we’re down from 452 rows to 18 rows. Narrowing it down further…

subset(assem.data[[3]], unit_name=="Primary Assembly" & mol_name=="all" & mol_type=="all" &seq_type=="all")

This narrows it down from 18 rows to 6 rows… And now that “total-length” is unique in this vector, we can extract just that row. Same for “ungapped-length”. I’ll store these to variables.

total<-subset(assem.data[[3]], unit_name=="Primary Assembly" & mol_name=="all" & mol_type=="all" &seq_type=="all" & stat=="total-length")
ungapped<-subset(assem.data[[3]], unit_name=="Primary Assembly" & mol_name=="all" & mol_type=="all" &seq_type=="all" & stat=="ungapped-length")

(Starting over) Extract data based on column names:

get_total_length_allcols<- function (x) '[' (x[x$unit_name %in% "Primary Assembly"
                                       &x$mol_name %in% "all"
                                       &x$mol_type %in% "all"
                                       &x$seq_type %in% "all"
                                       &x$stat %in% "total-length" ,] )
get_ungapped_length_allcols<- function (x) '[' (x[x$unit_name %in% "Primary Assembly"
                                          &x$mol_name %in% "all"
                                          &x$mol_type %in% "all"
                                          &x$seq_type %in% "all"
                                          &x$stat %in% "ungapped-length" ,] )

get_mito_allcols<- function (x) '[' (x[x$unit_name %in% "non-nuclear"
                               &x$mol_name %in% "MT"
                               &x$mol_type %in% "Mitochondrion"
                               &x$seq_type %in% "all"
                               &x$stat %in% "total-length" ,] )

total_all<-lapply(assem.data,get_total_length_allcols)
ungapped_all<-lapply(assem.data,get_ungapped_length_allcols)
mito_all<-lapply(assem.data,get_mito_allcols)

Change all of the above functions to get only the “value” column (keep the functions in the previous chunk for testing)

get_total_length_val<- function (x) '[' (x[x$unit_name %in% "Primary Assembly"
                          &x$mol_name %in% "all"
                          &x$mol_type %in% "all"
                          &x$seq_type %in% "all"
                          &x$stat %in% "total-length" ,"value"] )

get_ungapped_length_val<- function (x) '[' (x[x$unit_name %in% "Primary Assembly"
                                   &x$mol_name %in% "all"
                                   &x$mol_type %in% "all"
                                   &x$seq_type %in% "all"
                                   &x$stat %in% "ungapped-length" ,"value"] )

get_mito_val<- function (x) '[' (x[x$unit_name %in% "non-nuclear"
                                      &x$mol_name %in% "MT"
                                      &x$mol_type %in% "Mitochondrion"
                                      &x$seq_type %in% "all"
                                      &x$stat %in% "total-length" ,"value"] )

total<-lapply(assem.data,get_total_length_val)
ungapped<-lapply(assem.data,get_ungapped_length_val)
mito<-lapply(assem.data,get_mito_val)

Bind total, ungapped and mito into lists

head(cbind(total))

Bind each new list again:

head(cbind(cbind(total),cbind(ungapped),cbind(mito)))

Can do this all in one step:

assem.data_vals<- rbind.data.frame(cbind(cbind(total),cbind(ungapped),cbind(mito)))
colnames(assem.data_vals)<-c("total","ungapped","mito")
head(assem.data_vals)
#printing chunk doesn't work, code works in console

head(df) total ungapped mito 1 143706478 142553500 19524 2 16299 3 2870167880 2729969191 16313 4 3196721236 3118525743 16866 5 1373454788 1368765506 16596 6 927296314 737783370 14117

Row 2 is missing values? Row 2 organism is Mus musculus In the raw data, not compatible with this line in the functions above: get_total_length_val<- function (x) ‘[’ (x[x$unit_name %in% “Primary Assembly” In this file, “Primary Assembly” is written as “Primary Assembly (C57BL/6J)”, which is not considered a match by %in%….

Try writing a new operator for partial matches?

#examples
#"%in%" <- function(x, table) match(x, table, nomatch = 0) > 0
#example `%allin%` <- function(x,table) {all(match(x,table,nomatch = 0L) > 0L)}
#str(startsWith) is function (x,prefix) 
`%starts%` <- function(x, string) {startsWith(as.character(x), string)}

Replace this operator into the functions for getting total-length, etc.

get_total_length_val<- function (x) '[' (x[x$unit_name %starts% "Primary Assembly"
                          &x$mol_name %in% "all"
                          &x$mol_type %in% "all"
                          &x$seq_type %in% "all"
                          &x$stat %in% "total-length" ,"value"] )

get_ungapped_length_val<- function (x) '[' (x[x$unit_name %starts% "Primary Assembly"
                                   &x$mol_name %in% "all"
                                   &x$mol_type %in% "all"
                                   &x$seq_type %in% "all"
                                   &x$stat %in% "ungapped-length" ,"value"] )
get_mito_val<- function (x) '[' (x[x$unit_name %in% "non-nuclear"
                                      &x$mol_name %in% "MT"
                                      &x$mol_type %in% "Mitochondrion"
                                      &x$seq_type %in% "all"
                                      &x$stat %in% "total-length" ,"value"] )

total<-lapply(assem.data,get_total_length_val)
ungapped<-lapply(assem.data,get_ungapped_length_val)
mito<-lapply(assem.data,get_mito_val)

assem.data_vals<- rbind.data.frame(cbind(cbind(total),cbind(ungapped),cbind(mito)))
colnames(assem.data_vals)<-c("total","ungapped","mito")

It works!!

head(df) total ungapped mito 1 143706478 142553500 19524 2 2730855475 2652767259 16299 3 2870167880 2729969191 16313 4 3196721236 3118525743 16866 5 1373454788 1368765506 16596 6 927296314 737783370 14117

Now cbind an ID value for each row:

assem.data_vals<-cbind("ID"=rownames(assem.data_vals), assem.data_vals)

Section 3: Combine names and data

Finally, combining organism names with their respective data:

assemblies<-cbind(lna,assem.data_vals)

Export data frame to csv

Write the Organism column to csv so we can use it to query in python: Extract just the Organism column into a new data frame:

assemblies.orgs<-data.frame("Organism"=cbind(assemblies[,"Organism"]))

Write that column to csv:

assemblies.orgs<-apply(assemblies.orgs,2,as.character)
write.csv(assemblies.orgs, "assembliesorgs.csv")

Part 2: Making a Python SQLite database

The next thing I decided to do was get the taxonomy information from each organism to add to the table. To do this, I used the BioEntrez package for Python. This enables queries from Entrez. (I’m using anaconda with Spyder)

Fetching organism xml files from Entrez

(read_csv.py)
Setup:

from Bio import Entrez
Entrez.email = ' '
import csv
import lxml
import pprint
from lxml import etree
import time
import numpy as np
import traceback

Get a list of organism names from the csv file made in Part 1:


csvfile=(r'\assembliesorgs.csv')

ids=[]
orglist=[]
with open(csvfile,'rt') as f:
  data = csv.reader(f)
  for row in data:
      ids.append(row[0])
      orglist.append(row[1])

Fetch xml files with taxonomy results from orglist, store in orgs

orgs=[]
def fetchorgs(x):
    try:
        for idx,org in enumerate(x):
            query= Entrez.esearch(db="taxonomy",term= org, retmax=1)
            result=Entrez.read(query)
            handle=Entrez.efetch(db="taxonomy",id=result['IdList'])
            result=handle.read()
            orgs.append(result)
            if idx % 10==0:
                print(len(orgs),"records fetched")
    except Exception as e:
        print(e,idx,org)

#DO NOT FETCH MORE THAN 100 AT A TIME
#DO THIS ON WEEKENDS OR US DOWNTIMES
fetchorgs(orglist[100:101]) #Total number was 450, I modified this line to 0:100, 100:200, 200:300 etc to avoid too many requests at once.

Check if any records from orglist are missing in orgs:

for c,i in enumerate(orgs):
    try:
        i=bytes(i,encoding='utf8')
        A=etree.fromstring(i).find('Taxon/ScientificName').text
        if A not in orglist:
            print(c,A)
    except Exception as e:
        print(c,e)

Extracting taxonomy data from xml files

(organism_data.py) Setup:

from Bio import Entrez
Entrez.email = 'mcglynnkell@gmail.com'
import csv
import lxml
import pprint
from lxml import etree
import pandas as pd
import traceback

Using lxml and etree to extract data from the xml files. There are 10 values to get for each organism name: TaxId, ScientificName, CommonName, Division, Kingdom, Phylum, Class, Order, Family and Genus.

#Set up empty lists
TaxId_list=[]
ScientificName_list=[]
CommonName_list=[]
Division_list=[]
Kingdom_list=[]
Phylum_list=[]
Class_list=[]
Order_list=[]
Family_list=[]
Genus_list=[]

#Function to extract data from orgsfetched (a list that was generated
#from the fetchorgs function)
def extract_data(orgsfetched):
    for idx, i in enumerate(orgsfetched):
        if len(i)>260:    #excludes results that failed to fetch
            i=bytes(i,encoding='utf8')
            TaxId=etree.fromstring(i).find('Taxon/TaxId')
                    
            ScientificName= etree.fromstring(i).find('Taxon/ScientificName')
                       
            CommonName=etree.fromstring(i).find('Taxon/OtherNames/GenbankCommonName')
                 
            Division=etree.fromstring(i).find('Taxon/Division')  
                    
            Kingdom=etree.fromstring(i).xpath(
                    '//Rank[text()="superkingdom"]/preceding-sibling::ScientificName/text()')
            
            Phylum=etree.fromstring(i).xpath(
                    '//Rank[text()="phylum"]/preceding-sibling::ScientificName/text()')
                
            Class=etree.fromstring(i).xpath(
                    '//Rank[text()="class"]/preceding-sibling::ScientificName/text()')
                    
            Order=etree.fromstring(i).xpath(
                    '//Rank[text()="order"]/preceding-sibling::ScientificName/text()')
                    
            Family=etree.fromstring(i).xpath(
                    '//Rank[text()="family"]/preceding-sibling::ScientificName/text()')
                    
            Genus=etree.fromstring(i).xpath(
                    '//Rank[text()="genus"]/preceding-sibling::ScientificName/text()')
                        
            data1=[TaxId,ScientificName,CommonName,Division,
                   Kingdom,Phylum,Class,Order,Family,Genus]
            for idxx,d in enumerate(data1):
                if d is None:
                   data1[idxx]=etree.Element("empty")
                   data1[idxx].text="NULL"  
                elif len(d)==0:
                    if not hasattr(d,'text'):
                        data1[idxx]=["NULL"]
                
            try:         
                TaxId_list.append(data1[0].text)
                ScientificName_list.append(data1[1].text)
                CommonName_list.append(data1[2].text)
                Division_list.append(data1[3].text)
                Kingdom_list.append(data1[4][0])
                Phylum_list.append(data1[5][0])
                Class_list.append(data1[6][0]) 
                Order_list.append(data1[7][0])
                Family_list.append(data1[8][0])
                Genus_list.append(data1[9][0])
            except AttributeError as Att:
                print(idx, "NoneType",Att, traceback.format_exc())
            except IndexError as Ind:
                print(idx,"index",Ind, traceback.format_exc())

Make a data frame from the extracted taxonomy data:

org_dataframe = pd.DataFrame(
        {'TaxId' : TaxId_list,
         'ScientificName' : ScientificName_list, 
         'CommonName' : CommonName_list,
         'Division' : Division_list,                     
         'Kingdom' : Kingdom_list,
         'Phylum' : Phylum_list,
         'Class' : Class_list,
         'Order' : Order_list,
         'Family': Family_list,
         'Genus' : Genus_list})

Add taxonomy data to an SQLite database

(database.py)
After putting this data frame into a database, I can then query the database back in R. (And this way, I learn about SQLite databases!)

Create a local database with sqlite:

import sqlite3, sqlalchemy
import pandas as pd

from sqlalchemy import create_engine
engine= create_engine('sqlite:/// <PATH> \\Organismdb.db',
                      echo=True)

from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()

from sqlalchemy import Table, Column, Integer, String
class Organism(Base):
    __tablename__ = 'Organisms'
    
    TaxId= Column(Integer, index = True, primary_key = True)
    Scientific_Name = Column(String)
    Common_Name= Column(String)
    Division= Column(String)
    Kingdom= Column(String)
    Phylum= Column(String)
    Class= Column(String)
    Order= Column(String)
    Family= Column(String)
    Genus= Column(String)
    
    def __init__(self, TaxId,ScientificName,CommonName,Division,
               Kingdom,Phylum,Class,Order,Family,Genus, **kw):
        self.TaxId = TaxId
        self.ScientificName = ScientificName
        self.CommonName = CommonName
        self.Division = Division
        self.Kingdom = Kingdom
        self.Phylum = Phylum
        self.Class = Class
        self.Order = Order
        self.Family = Family
        self.Genus = Genus
           
Base.metadata.create_all(engine)

Organisms.__table__ 

#Notes on the commands needed to add to the database:   
from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
session = Session()

session.commit()
session.close()

(input_dbdata.py)

from sqlalchemy import create_engine
engine= create_engine('sqlite:/// <PATH> \\Organismdb.db',
                      echo=True)
conn = sqlite3.connect('Organismdb.db')
cursor = conn.cursor()

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
session = Session()




for col in org_dataframe.columns: 
    print(col) 

#Input all data in pandas dataframe into table 'Organisms'
org_dataframe.to_sql('Organisms', con=engine, if_exists='replace')

session.commit()
session.close()

The database is all set up!

Back to R!

Part 3: Querying the Organisms.db SQLite database in R

The last step is to query the data from Organisms.db in R and append the new data to the assemblies R dataframe.

Setup:

library(RSQLite)
library(dbplyr)
library(dplyr)
library(DBI)

##Connect to SQLite database in R

con <- DBI::dbConnect(RSQLite::SQLite(), dbname = "<PATH> \\Organismdb.db")

Check if the connection worked:

attributes(con)
dbListTables(con)
dbExistsTable(con,"Organisms")

dbListFields(con,"Organisms")

View table!

tbl(con,"Organisms")

Write a function to query the database from the assemblies dataframe:

query<- function(nx) {
x<-dbSendQuery(con, 
               'SELECT * 
             FROM Organisms WHERE ScientificName == ?')
dbBind(x,list(nx))
z<-(dbFetch(x,n=1)) #n=1 specifies results to return, doesn't work as well if multiple results are fetched
dbClearResult(x) #VERY important! VERY!
return(z)
dbClearResult(x) #VERY important! VERY!
}

Query append new columns from SQLite database

db_results<-data.frame()  #make a new data.frame

for (i in assemblies[,"Organism"]) {
  x<-query(i)
  if (nrow(x)==0) {
    x[nrow(x)+1,]<- c(rep("NULL",11))}
  db_results<-rbind(db_results,x)}

#Bind new columns to assemblies dataframe
assemblies_complete<-cbind(assemblies,db_results)

If there are any entries missing in db_results, db_results won’t cbind to assemblies(differing numbers of rows). Double check:

which(assemblies[,"Organism"] %starts% "Drosophila melanogaster")

Check which rows are missing:

'%!in%' <- function(x,y)!('%in%'(x,y))
which(assemblies[,"Organism"] %!in% db_results[,"ScientificName"])

which(db_results[,"ScientificName"] %!in% assemblies[,"Organism"])

Verify that Organism matches Scientific Name in all rows

which(assemblies_complete[,"Organism"] != assemblies_complete[,"ScientificName"])

Rows 100,200 and 400 weren’t in the database! Print out the missing rows so I can go back to the Python script and add the missing data to the db.

assemblies_complete[c(100,200,400),]

I then went back to the python scripts and added the missing values from rows 100, 200 and 400, running these final R scripts again afterwards.

All done!

Now this dataset can be used to do some interesting analysis and visualizations, such as comparing genome size and mitochondrial genome size among the organisms in this dataset, and relationships between genome size and a particular taxonomic class.

---
title: "NCBI Genome Assemblies Project - Getting and Cleaning Data in R and Python"
output:
  html_notebook:
    toc: true
    toc_float: 
      collapsed: false
      smooth_scroll: false
---

This is a project to practice getting and cleaning data in R and Python!  
There are three notebooks for this project in the table of contents.

The goal behind this project is to collect data on genome sizes from various organisms on NCBI, generating a table that can be used to analyze which genome sizes (or mitchondrial genome sizes) are the largest (Part 1).  I also decided to write some python scripts (Part 2) using the BioEntrez package to query Entrez on NCBI and collect taxonomy information for each organism to add to the table.  Finally, I generated a local SQLite database to hold the BioEntrez taxonomy data, and then queried the database in R to add the new data to the dataframe (Part 3).

# Part 1: Getting and cleaning data from genome assemblies statistics files

Setup
```{r}
library(dplyr)
library(ggplot2)
```

Downloaded multiple text files containing the genome sizes of multiple organisms.  The goal is to extract just the organism names, total genome length, and maybe mitochondrial genome length just for fun!

Here's what the files look like:      
Each file has an upper section that contains organism information such as scientific name and common name....       
      
      
      
      
![](GCF_9-1.png)     



And a lower section containing genome size data:       
       
       
       
       
![](GCF_9-2.png)      



The organism name and genome length data (we want the "Primary Assembly, total-length and ungapped-length lines) are in seperate parts of the file.  We'll need to extract and then combine them to be able to compare between organisms.


The first thing I tried was to get a table with the genome size with just one of the txt files.
```{r}
assembliesR<-read.delim("~/ncbi-genomes-2019-05-19/GCF_900747795.1_fErpCal1.1_assembly_stats.txt",sep="",header=F,fill=TRUE,comment.char="#")
print(assembliesR[1:15,]) 
```

Ok, we have 6 columns containing the data we need, but the organism name isn't listed because it's # commented in the txt file.

After some testing, I decided to extract the genome size data and the organism name from the text files with two separate scripts...

## Section 1: Organism Names

First, the names:
```{r}
fdir<-list.files("~/ncbi-genomes-2019-05-19", 
                 pattern=".txt",full.names=T)
#450 files total
fdir<-(c(fdir[1:448])) #remove 449 and 450, empty files
```
Now I have a list of all the text files.

```{r}
#Read the txt files, including # header containing names
assem.n<-lapply(fdir, function(i) {
  read.delim(i,
      sep=" ",
      header=F,
      fill=T,
      comment.char="")})
```

```{r}
#Get name based on row locations.... !doesn't work for all files
get_name<- function(x){
  x[3,4:6]
}
#apply function to all files
N<- lapply(assem.n, get_name)

```
This extracts the names for some of the files, but not all...
```{r}
print(N[4:12])
```

Need to find a way to extract based on the string preceding the organism name...

(Starting over)
```{r}
assem.n<-lapply(fdir, function(i) {
  read.delim(i,
             sep=" ",
             header=F,
             fill=T,
             comment.char="") })

top_only<- function(x) '[' (x[1:20,])
assem.n<-lapply(assem.n,top_only)
cut_columns<- function(x) x[,2:7]
assem.n<-lapply(assem.n,cut_columns)

get_name<- function (x) '[' (x[which(x[,]=="Organism"),])
nn<-lapply(assem.n,get_name)
```
This works a lot better!
Now nn can be converted to a data frame of organism names:
```{r}

paste_species<- function(name_) {
  paste(name_$V5, name_$V6, sep=" ")
}
lnames<- lapply(nn,paste_species)
dfnames <- data.frame(matrix(unlist(lnames), nrow=length(lnames),
            byrow=T),stringsAsFactors=FALSE)
colnames(dfnames)<-"Organism"
head(dfnames)
```
It would be better to assign an ID to each organism name, so it can be linked to the data later...

```{r}
lnames<- lapply(nn,paste_species)

lna<-rbind.data.frame((cbind(lnames)), make.row.names = F)
print(head(lna))
colnames(lna)<-"Organism"
lna2<-cbind("ID"=rownames(lna), lna)
#print(head(lna2))
#printing in the chunk doesn't seem to work here... this code works in console

#Check if ID column value matches the organism's original position
#in the list of assemblies files:
print(lna[448,])
print(nn[[448]])
print(assem.n[[448]])

```



## Section 2: Genome data

This is a bit easier, since I can use the same function but exclude all of the commented text at the top, leaving just the data table at the bottom.
Here's the example again:
```{r}
example<-read.delim("~/ncbi-genomes-2019-05-19/GCF_900747795.1_fErpCal1.1_assembly_stats.txt", sep="\t", col.names=colnames, comment.char="#")
print(example[1:15,])
```

Reading the data into R the same way as the names script, this time using comment character '#' and assigning column names.
```{r}
colnames<-c("unit_name","mol_name","mol_type","seq_type","stat","value")

assem.data<-lapply(fdir, function(i){
    read.delim(i,
      sep="\t",
      header=F,
      fill=T,
      comment.char="#",
      col.names=colnames)})

print(assem.data[[3]][1:10,])
```


Now, test extracting just the "Primary Assembly" rows with mol_name = all.  Just use assem.data[[3]] to test.
```{r}
subset(assem.data[[3]], unit_name=="Primary Assembly" & mol_name=="all")
```
Now, for file 3, we're down from 452 rows to 18 rows. Narrowing it down further...
```{r}
subset(assem.data[[3]], unit_name=="Primary Assembly" & mol_name=="all" & mol_type=="all" &seq_type=="all")
```
This narrows it down from 18 rows to 6 rows... And now that "total-length" is unique in this vector, we can extract just that row.  Same for "ungapped-length".  I'll store these to variables.
```{r}
total<-subset(assem.data[[3]], unit_name=="Primary Assembly" & mol_name=="all" & mol_type=="all" &seq_type=="all" & stat=="total-length")
ungapped<-subset(assem.data[[3]], unit_name=="Primary Assembly" & mol_name=="all" & mol_type=="all" &seq_type=="all" & stat=="ungapped-length")
```

(Starting over)
Extract data based on column names:
```{r}
get_total_length_allcols<- function (x) '[' (x[x$unit_name %in% "Primary Assembly"
                                       &x$mol_name %in% "all"
                                       &x$mol_type %in% "all"
                                       &x$seq_type %in% "all"
                                       &x$stat %in% "total-length" ,] )
get_ungapped_length_allcols<- function (x) '[' (x[x$unit_name %in% "Primary Assembly"
                                          &x$mol_name %in% "all"
                                          &x$mol_type %in% "all"
                                          &x$seq_type %in% "all"
                                          &x$stat %in% "ungapped-length" ,] )

get_mito_allcols<- function (x) '[' (x[x$unit_name %in% "non-nuclear"
                               &x$mol_name %in% "MT"
                               &x$mol_type %in% "Mitochondrion"
                               &x$seq_type %in% "all"
                               &x$stat %in% "total-length" ,] )

total_all<-lapply(assem.data,get_total_length_allcols)
ungapped_all<-lapply(assem.data,get_ungapped_length_allcols)
mito_all<-lapply(assem.data,get_mito_allcols)
```

Change all of the above functions to get only the "value" column (keep the functions in the previous chunk for testing)

```{r}
get_total_length_val<- function (x) '[' (x[x$unit_name %in% "Primary Assembly"
                          &x$mol_name %in% "all"
                          &x$mol_type %in% "all"
                          &x$seq_type %in% "all"
                          &x$stat %in% "total-length" ,"value"] )

get_ungapped_length_val<- function (x) '[' (x[x$unit_name %in% "Primary Assembly"
                                   &x$mol_name %in% "all"
                                   &x$mol_type %in% "all"
                                   &x$seq_type %in% "all"
                                   &x$stat %in% "ungapped-length" ,"value"] )

get_mito_val<- function (x) '[' (x[x$unit_name %in% "non-nuclear"
                                      &x$mol_name %in% "MT"
                                      &x$mol_type %in% "Mitochondrion"
                                      &x$seq_type %in% "all"
                                      &x$stat %in% "total-length" ,"value"] )

total<-lapply(assem.data,get_total_length_val)
ungapped<-lapply(assem.data,get_ungapped_length_val)
mito<-lapply(assem.data,get_mito_val)

```
Bind total, ungapped and mito into lists
```{r}
head(cbind(total))
```
Bind each new list again:
```{r}
head(cbind(cbind(total),cbind(ungapped),cbind(mito)))
```

Can do this all in one step:
```{r}
assem.data_vals<- rbind.data.frame(cbind(cbind(total),cbind(ungapped),cbind(mito)))
colnames(assem.data_vals)<-c("total","ungapped","mito")
head(assem.data_vals)
#printing chunk doesn't work, code works in console
```
> head(df)
       total   ungapped  mito
1  143706478  142553500 19524
2                       16299
3 2870167880 2729969191 16313
4 3196721236 3118525743 16866
5 1373454788 1368765506 16596
6  927296314  737783370 14117

Row 2 is missing values?
Row 2 organism is Mus musculus
In the raw data, not compatible with this line in the functions above:
get_total_length_val<- function (x) '[' (x[x$unit_name %in% "Primary Assembly"
In this file, "Primary Assembly" is written as "Primary Assembly (C57BL/6J)", which is not considered a  match by %in%....

Try writing a new operator for partial matches?
```{r}
#examples
#"%in%" <- function(x, table) match(x, table, nomatch = 0) > 0
#example `%allin%` <- function(x,table) {all(match(x,table,nomatch = 0L) > 0L)}
#str(startsWith) is function (x,prefix) 
```
```{r}
`%starts%` <- function(x, string) {startsWith(as.character(x), string)}
```
Replace this operator into the functions for getting total-length, etc.
```{r}
get_total_length_val<- function (x) '[' (x[x$unit_name %starts% "Primary Assembly"
                          &x$mol_name %in% "all"
                          &x$mol_type %in% "all"
                          &x$seq_type %in% "all"
                          &x$stat %in% "total-length" ,"value"] )

get_ungapped_length_val<- function (x) '[' (x[x$unit_name %starts% "Primary Assembly"
                                   &x$mol_name %in% "all"
                                   &x$mol_type %in% "all"
                                   &x$seq_type %in% "all"
                                   &x$stat %in% "ungapped-length" ,"value"] )
get_mito_val<- function (x) '[' (x[x$unit_name %in% "non-nuclear"
                                      &x$mol_name %in% "MT"
                                      &x$mol_type %in% "Mitochondrion"
                                      &x$seq_type %in% "all"
                                      &x$stat %in% "total-length" ,"value"] )

total<-lapply(assem.data,get_total_length_val)
ungapped<-lapply(assem.data,get_ungapped_length_val)
mito<-lapply(assem.data,get_mito_val)

assem.data_vals<- rbind.data.frame(cbind(cbind(total),cbind(ungapped),cbind(mito)))
colnames(assem.data_vals)<-c("total","ungapped","mito")
```

It works!!

> head(df)
       total   ungapped  mito
1  143706478  142553500 19524
2 2730855475 2652767259 16299
3 2870167880 2729969191 16313
4 3196721236 3118525743 16866
5 1373454788 1368765506 16596
6  927296314  737783370 14117

Now cbind an ID value for each row:
```{r}
assem.data_vals<-cbind("ID"=rownames(assem.data_vals), assem.data_vals)
```

## Section 3: Combine names and data
Finally, combining organism names with their respective data:

```{r}
assemblies<-cbind(lna,assem.data_vals)
```


## Export data frame to csv
Write the Organism column to csv so we can use it to 
query in python:
Extract just the Organism column into a new data frame:
```{r}
assemblies.orgs<-data.frame("Organism"=cbind(assemblies[,"Organism"]))
```

Write that column to csv:
```{r}
assemblies.orgs<-apply(assemblies.orgs,2,as.character)
write.csv(assemblies.orgs, "assembliesorgs.csv")
```

# Part 2: Making a Python SQLite database

The next thing I decided to do was get the taxonomy information from each organism to add to the table.  To do this, I used the BioEntrez package for Python.  This enables queries from Entrez.
(I'm using anaconda with Spyder)

### Fetching organism xml files from Entrez
*(read_csv.py)*     
Setup:
```{python}
from Bio import Entrez
Entrez.email = ' '
import csv
import lxml
import pprint
from lxml import etree
import time
import numpy as np
import traceback
```

Get a list of organism names from the csv file made in Part 1:
```{python}

csvfile=(r'\assembliesorgs.csv')

ids=[]
orglist=[]
with open(csvfile,'rt') as f:
  data = csv.reader(f)
  for row in data:
      ids.append(row[0])
      orglist.append(row[1])
```

Fetch xml files with taxonomy results from orglist, store in orgs
```{python}
orgs=[]
def fetchorgs(x):
    try:
        for idx,org in enumerate(x):
            query= Entrez.esearch(db="taxonomy",term= org, retmax=1)
            result=Entrez.read(query)
            handle=Entrez.efetch(db="taxonomy",id=result['IdList'])
            result=handle.read()
            orgs.append(result)
            if idx % 10==0:
                print(len(orgs),"records fetched")
    except Exception as e:
        print(e,idx,org)

#DO NOT FETCH MORE THAN 100 AT A TIME
#DO THIS ON WEEKENDS OR US DOWNTIMES
fetchorgs(orglist[100:101]) #Total number was 450, I modified this line to 0:100, 100:200, 200:300 etc to avoid too many requests at once.
```

Check if any records from orglist are missing in orgs:
```{python}
for c,i in enumerate(orgs):
    try:
        i=bytes(i,encoding='utf8')
        A=etree.fromstring(i).find('Taxon/ScientificName').text
        if A not in orglist:
            print(c,A)
    except Exception as e:
        print(c,e)
```

## Extracting taxonomy data from xml files
*(organism_data.py)*
Setup:
```{python}
from Bio import Entrez
Entrez.email = 'mcglynnkell@gmail.com'
import csv
import lxml
import pprint
from lxml import etree
import pandas as pd
import traceback
```

Using lxml and etree to extract data from the xml files.  There are 10 values to get for each organism name: TaxId, ScientificName, CommonName, Division, Kingdom, Phylum, Class, Order, Family and Genus.
```{python}
#Set up empty lists
TaxId_list=[]
ScientificName_list=[]
CommonName_list=[]
Division_list=[]
Kingdom_list=[]
Phylum_list=[]
Class_list=[]
Order_list=[]
Family_list=[]
Genus_list=[]

#Function to extract data from orgsfetched (a list that was generated
#from the fetchorgs function)
def extract_data(orgsfetched):
    for idx, i in enumerate(orgsfetched):
        if len(i)>260:    #excludes results that failed to fetch
            i=bytes(i,encoding='utf8')
            TaxId=etree.fromstring(i).find('Taxon/TaxId')
                    
            ScientificName= etree.fromstring(i).find('Taxon/ScientificName')
                       
            CommonName=etree.fromstring(i).find('Taxon/OtherNames/GenbankCommonName')
                 
            Division=etree.fromstring(i).find('Taxon/Division')  
                    
            Kingdom=etree.fromstring(i).xpath(
                    '//Rank[text()="superkingdom"]/preceding-sibling::ScientificName/text()')
            
            Phylum=etree.fromstring(i).xpath(
                    '//Rank[text()="phylum"]/preceding-sibling::ScientificName/text()')
                
            Class=etree.fromstring(i).xpath(
                    '//Rank[text()="class"]/preceding-sibling::ScientificName/text()')
                    
            Order=etree.fromstring(i).xpath(
                    '//Rank[text()="order"]/preceding-sibling::ScientificName/text()')
                    
            Family=etree.fromstring(i).xpath(
                    '//Rank[text()="family"]/preceding-sibling::ScientificName/text()')
                    
            Genus=etree.fromstring(i).xpath(
                    '//Rank[text()="genus"]/preceding-sibling::ScientificName/text()')
                        
            data1=[TaxId,ScientificName,CommonName,Division,
                   Kingdom,Phylum,Class,Order,Family,Genus]
            for idxx,d in enumerate(data1):
                if d is None:
                   data1[idxx]=etree.Element("empty")
                   data1[idxx].text="NULL"  
                elif len(d)==0:
                    if not hasattr(d,'text'):
                        data1[idxx]=["NULL"]
                
            try:         
                TaxId_list.append(data1[0].text)
                ScientificName_list.append(data1[1].text)
                CommonName_list.append(data1[2].text)
                Division_list.append(data1[3].text)
                Kingdom_list.append(data1[4][0])
                Phylum_list.append(data1[5][0])
                Class_list.append(data1[6][0]) 
                Order_list.append(data1[7][0])
                Family_list.append(data1[8][0])
                Genus_list.append(data1[9][0])
            except AttributeError as Att:
                print(idx, "NoneType",Att, traceback.format_exc())
            except IndexError as Ind:
                print(idx,"index",Ind, traceback.format_exc())
```
    
Make a data frame from the extracted taxonomy data:
```{python}
org_dataframe = pd.DataFrame(
        {'TaxId' : TaxId_list,
         'ScientificName' : ScientificName_list, 
         'CommonName' : CommonName_list,
         'Division' : Division_list,                     
         'Kingdom' : Kingdom_list,
         'Phylum' : Phylum_list,
         'Class' : Class_list,
         'Order' : Order_list,
         'Family': Family_list,
         'Genus' : Genus_list})
    
```

### Add taxonomy data to an SQLite database
*(database.py)*    
After putting this data frame into a database, I can then query the database back in R. (And this way, I learn about SQLite databases!)

Create a local database with sqlite:
```{python}
import sqlite3, sqlalchemy
import pandas as pd

from sqlalchemy import create_engine
engine= create_engine('sqlite:/// <PATH> \\Organismdb.db',
                      echo=True)

from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()

from sqlalchemy import Table, Column, Integer, String
class Organism(Base):
    __tablename__ = 'Organisms'
    
    TaxId= Column(Integer, index = True, primary_key = True)
    Scientific_Name = Column(String)
    Common_Name= Column(String)
    Division= Column(String)
    Kingdom= Column(String)
    Phylum= Column(String)
    Class= Column(String)
    Order= Column(String)
    Family= Column(String)
    Genus= Column(String)
    
    def __init__(self, TaxId,ScientificName,CommonName,Division,
               Kingdom,Phylum,Class,Order,Family,Genus, **kw):
        self.TaxId = TaxId
        self.ScientificName = ScientificName
        self.CommonName = CommonName
        self.Division = Division
        self.Kingdom = Kingdom
        self.Phylum = Phylum
        self.Class = Class
        self.Order = Order
        self.Family = Family
        self.Genus = Genus
           
Base.metadata.create_all(engine)

Organisms.__table__ 

#Notes on the commands needed to add to the database:   
from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
session = Session()

session.commit()
session.close()
```


*(input_dbdata.py)* 
```{python}
from sqlalchemy import create_engine
engine= create_engine('sqlite:/// <PATH> \\Organismdb.db',
                      echo=True)
conn = sqlite3.connect('Organismdb.db')
cursor = conn.cursor()

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
session = Session()




for col in org_dataframe.columns: 
    print(col) 

#Input all data in pandas dataframe into table 'Organisms'
org_dataframe.to_sql('Organisms', con=engine, if_exists='replace')

session.commit()
session.close()
```
The database is all set up!

Back to R!

# Part 3: Querying the Organisms.db SQLite database in R

The last step is to query the data from Organisms.db in R and append the new data to the assemblies R dataframe.

Setup:
```{r}
library(RSQLite)
library(dbplyr)
library(dplyr)
library(DBI)
```

##Connect to SQLite database in R
```{r}
con <- DBI::dbConnect(RSQLite::SQLite(), dbname = "<PATH> \\Organismdb.db")

```

Check if the connection worked:
```{r}
attributes(con)
dbListTables(con)
dbExistsTable(con,"Organisms")

dbListFields(con,"Organisms")
```

View table!
```{r}
tbl(con,"Organisms")
```

Write a function to query the database from the assemblies dataframe:
```{r}
query<- function(nx) {
x<-dbSendQuery(con, 
               'SELECT * 
             FROM Organisms WHERE ScientificName == ?')
dbBind(x,list(nx))
z<-(dbFetch(x,n=1)) #n=1 specifies results to return, doesn't work as well if multiple results are fetched
dbClearResult(x) #VERY important! VERY!
return(z)
dbClearResult(x) #VERY important! VERY!
}
```

## Query append new columns from SQLite database
```{r}
db_results<-data.frame()  #make a new data.frame

for (i in assemblies[,"Organism"]) {
  x<-query(i)
  if (nrow(x)==0) {
    x[nrow(x)+1,]<- c(rep("NULL",11))}
  db_results<-rbind(db_results,x)}

#Bind new columns to assemblies dataframe
assemblies_complete<-cbind(assemblies,db_results)
```

If there are any entries missing in db_results, db_results won't cbind to assemblies(differing numbers of rows). Double check:
```{r}
which(assemblies[,"Organism"] %starts% "Drosophila melanogaster")
```

Check which rows are missing:
```{r}
'%!in%' <- function(x,y)!('%in%'(x,y))
which(assemblies[,"Organism"] %!in% db_results[,"ScientificName"])

which(db_results[,"ScientificName"] %!in% assemblies[,"Organism"])
```

Verify that Organism matches Scientific Name in all rows
```{r}
which(assemblies_complete[,"Organism"] != assemblies_complete[,"ScientificName"])
```

Rows 100,200 and 400 weren't in the database!
Print out the missing rows so I can go back to the Python script and add the missing data to the db.
```{r}
assemblies_complete[c(100,200,400),]
```

I then went back to the python scripts and added the missing values from rows 100, 200 and 400, running these final R scripts again afterwards.


All done!

Now this dataset can be used to do some interesting analysis and visualizations, such as comparing genome size and mitochondrial genome size among the organisms in this dataset, and relationships between genome size and a particular taxonomic class.  
















