# Here are the three url's, of the web-page's that will be used, stored as variables.. 
chemidconvert = 'https://chemidconvert.cloud.douglasconnect.com/v1/'
tggatesconvert = 'http://open-tggates-api.cloud.douglasconnect.com/v2/'
bridgedb = "http://bridgedb.prod.openrisknet.org/Human/xrefs/X/"

"""This set, contains the chemical names of the compound that are used in this notebook.
To research different compounds, you need to change the names.
"""
compoundset = {'paracetamol', 'acetominophen', 'methapyrilene', 'phenylbutazone', 'simvastatin', 'valproic acid'}

pandas.set_option('display.max_colwidth', -1)  # Make the table.
compounds = pandas.DataFrame(columns=['Compound name', 'Smiles', 'Image'])

# Fill "compounds" with the "smiles" by the compound name.
for compound in compoundset:
    smiles = requests.get(chemidconvert + 'name/to/smiles', params={'name': compound}).json()['smiles']
    compounds = compounds.append({'Compound name': compound, 'Smiles': smiles, 'Image': smiles}, ignore_index=True)


def smiles_to_image_html(smiles):  # "smiles" shadows "smiles" from outer scope, use this function only in "to_html().
    """Gets for each smile the image, in HTML.
    :param smiles: Takes the “smiles” form “compounds”.
    :return: The HTML code for the image of the given smiles.
    """
    return '<img style="width:150px" src="' + chemidconvert+'asSvg?smiles='+urllib.parse.quote(smiles)+'"/>'


# Return a HTML table of "compounds", after "compounds" is fill by "smiles_to_image_html".
HTML(compounds.to_html(escape=False, formatters=dict(Image=smiles_to_image_html)))

# Again contact is maid with "TGGATES" to get more information from the samples.


#  The important variable "foldchanges" (which will be used till the last coding block) is made. 
foldchanges = pandas.DataFrame


for sample in samples["samples"]:
    sampleId = sample["sampleId"]
    sampleName = sample["compoundName"] + "\n" + sample["sampleId"]
    r3 = requests.get(tggatesconvert+'results',
                      params={'limit': 'none', 'sampleIdFilter': sampleId,
                              'valueTypeFilter': 'log2fold', 'pValueMax': '0.1'})  # The query is execute.

    """The  status code of the query is checked,
    and a temporarily data frame ("df") is created,
    to store the results of the query.
    """
    df = None
    if r3.status_code == 200:
        data = r3.json()
        df = pandas.DataFrame(data['results'])
        df = df.filter(items=['assayId', 'value'])
        df.columns = ['ProbeSet', sampleName]
    else:
        print("samples has not been created, because the TGGATES Status code was not 200. The code will now exit.")
        exit(1)

    # Every Temporarily data frame is added to  "foldchanges".
    if foldchanges.empty:
        foldchanges = df
    else:
        foldchanges = pandas.merge(foldchanges, df, how='outer', on=['ProbeSet'])

"""The variable "high" is set to be "true",
so that the "Bitwise Operator" "&" is true, as long as the foldchanges are not higher then 1
"""
high = True 

# Compare the fold change of the "samples", and chose the highest.
for sample in samples["samples"]:
    high = high & (foldchanges[sample["compoundName"] + "\n" + sample["sampleId"]] >= 1)

foldchanges = foldchanges[high]

% matplotlib inline

# Makes the heat map.
for_vis = foldchanges.set_index('ProbeSet')
plt.figure(figsize=(4, 4))
sns.set(font="Dejavu sans")
sns_plot = sns.heatmap(for_vis)  # type: object
sns_plot

#  Get the "Ensembl" and the "HGNC" in "foldchanges" as columns.
da = "?dataSource="  # The final part part to finis the url.
foldchanges['Ensembl'] = foldchanges.ProbeSet.apply(lambda url: requests.get(bridgedb+url+da+"En").text.split("\t")[0])
foldchanges['HGNC'] = foldchanges.ProbeSet.apply(lambda url: requests.get(bridgedb+url+da+"H").text.split("\t")[0])

# SPARQLWrapper makes it possible to use sparql queries on the web-page.
sparql = SPARQLWrapper("http://sparql.wikipathways.org")

# This is the creation of a data frame to store and represent data created in this coding block.
pathways = pandas.DataFrame(columns=['Gene', 'Ensembl', 'Pathway', 'Pathway Res', 'Pathway Title'])

genes = foldchanges['Ensembl']  # Here we continue with the "foldchanges".
results = None
for gene in genes:
    # Here the queries are made en the results are stored in "results".
    pathwayQuery = '''
      SELECT DISTINCT ?ensembl ?pathwayRes (str(?wpid) as ?pathway) (str(?title) as ?pathwayTitle)
      WHERE {{
        ?gene a wp:GeneProduct ;
          dcterms:identifier ?id ;
          dcterms:isPartOf ?pathwayRes ;
          wp:bdbEnsembl <http://identifiers.org/ensembl/{0}> .
        ?pathwayRes a wp:Pathway ;
          dcterms:identifier ?wpid ;
          dc:title ?title .
        BIND ( "{0}" AS ?ensembl )
      }}
    '''.format(gene)
    sparql.setQuery(pathwayQuery)
    sparql.setReturnFormat(JSON)  # Here the queries are made en the results are stored in "results".
    results = sparql.query().convert()

    for result in results["results"]["bindings"]:
        pathways = pathways.append({
            'Gene': foldchanges.loc[foldchanges['Ensembl'] == gene].iloc[0]["HGNC"],
            'Ensembl': result["ensembl"]["value"],
            'Pathway': result["pathway"]["value"],
            'Pathway Res': result["pathwayRes"]["value"],
            'Pathway Title': result["pathwayTitle"]["value"],
        }, ignore_index=True)

callUrl = 'https://webservice.bridgedb.org/Human/xrefs/H/MECP2'

lines = response.text.split("\n")
mappings = {}
for line in lines:
    if ('\t' in line):
        tuple = line.split('\t')
        identifier = tuple[0]
        database = tuple[1]
        if (database == "Ensembl"):
            mappings[identifier] = database

print(mappings)

callUrl = 'https://webservice.bridgedb.org/Human/xrefs/H/MECP2?dataSource=En'
response = requests.get(callUrl)
response.text