Example #1
0
def upload_to_itol(tree_path,
                   dataset_paths,
                   tree_name=None,
                   tree_description=None,
                   project_name=None,
                   upload_id=None):
    try:
        itol_uploader = Itol()
        itol_uploader.add_file(tree_path)
        for annotation_file in dataset_paths:
            itol_uploader.add_file(annotation_file)
        if tree_name:
            itol_uploader.params['treeName'] = tree_name
        if tree_description:
            itol_uploader.params['treeDescription'] = tree_description
        if upload_id:
            itol_uploader.params['uploadID'] = upload_id
            if project_name:
                itol_uploader.params['projectName'] = project_name
        if itol_uploader.upload():
            logging.getLogger('pastml').debug(
                'Successfully uploaded your tree ({}) to iTOL: {}.'.format(
                    itol_uploader.comm.tree_id, itol_uploader.get_webpage()))
            return itol_uploader.comm.tree_id, itol_uploader.get_webpage()
        else:
            status = itol_uploader.comm.upload_output
    except Exception as e:
        status = e
    logging.getLogger('pastml').error(
        'Failed to upload your tree to iTOL because of "{}". Please check your internet connection and itol settings{}.'
        .format(status, (', e.g. your iTOL batch upload id ({}){}'.format(
            upload_id,
            (' and whether the project {} exists'.format(project_name)
             if project_name else ''))) if upload_id else ''))
    return None, None
Example #2
0
def visualize_itol(request, taxonomy_id):
  newick_tree = services.newick_tree(taxonomy_id)
  tree_fh = NamedTemporaryFile(mode='w', suffix='.tree')
  tree_fh.write(newick_tree)
  tree_fh.flush()

  try:
    from itolapi import Itol
    itol_uploader = Itol()
    itol_uploader.add_file(tree_fh.name)
    status = itol_uploader.upload()
    assert status != False
    itol_page = itol_uploader.get_webpage()
    return redirect(itol_uploader.get_webpage())
  except:
    return HttpResponse('Something went wrong with the iTOL API. Save the following Newick tree to a file and upload it to iTOL yourself to visualize the tree:\n{}'.format(newick_tree), content_type = "text/plain")

  '''return HttpResponse(newick_tree)'''
Example #3
0
 def create_itol_link(process_ID, newick):
     with open(
             "/home/ubuntu/coxbase/tools/grapeTree/tre/{}.tree".format(
                 process_ID),
             "w",
             encoding="utf-8",
     ) as open_file:
         open_file.write(newick)
     itol_uploader = Itol()
     itol_uploader.add_file(
         "/home/ubuntu/coxbase/tools/grapeTree/tre/{}.tree".format(
             process_ID))
     itol_uploader.params["treeName"] = process_ID
     itol_uploader.upload()
     return itol_uploader.get_webpage()
Example #4
0
class ItolTest(unittest.TestCase):

    def setUp(self):
        self.itol = Itol()

    def test_initializes(self):
        self.assertEqual(type(self.itol.params), dict)
        self.assertEqual(self.itol.files, [])
        self.assertIsNotNone(self.itol.comm)

    def test_add_file(self):
        with tempfile.NamedTemporaryFile() as temp:
            self.itol.add_file(temp.name)
        with self.assertRaises(IOError):
            self.itol.add_file(' ')

    def test_good_upload(self):
        with patch('itolapi.Comm.upload_tree') as mock_upload:
            mock_upload.return_value = True
            self.itol.comm.tree_id = 1234
            self.assertEqual(self.itol.upload(), 1234)

    def test_bad_upload(self):
        with patch('itolapi.Comm.upload_tree') as mock_upload:
            mock_upload.return_value = False
            self.itol.comm.tree_id = 1234
            self.assertEqual(self.itol.upload(), 0)

    def test_get_webpage(self):
        self.itol.comm.tree_id = 'asdf'
        webpage = self.itol.get_webpage()
        self.assertIn('itol.embl.de', webpage)
        self.assertIn('asdf', webpage)

    def test_get_itol_export(self):
        self.itol.comm.tree_id = 1234
        export = self.itol.get_itol_export()
        self.assertEqual(export.params['tree'], 1234)

    @patch('itolapi.itol.pprint.pprint')
    def test_print_variables(self, mock_print):
        self.itol.params['treeName'] = 'test'
        with tempfile.NamedTemporaryFile() as temp:
            self.itol.add_file(temp.name)
            self.itol.print_variables()
        self.assertEqual(mock_print.call_args_list[0][0][0], self.itol.files)
        self.assertEqual(mock_print.call_args_list[1][0][0], self.itol.params)
Example #5
0
class ItolTest(unittest.TestCase):

    def setUp(self):
        self.itol = Itol()

    def test_initializes(self):
        self.assertEqual(type(self.itol.params), dict)
        self.assertEqual(self.itol.files, [])
        self.assertIsNotNone(self.itol.comm)

    def test_add_file(self):
        with tempfile.NamedTemporaryFile() as temp:
            self.itol.add_file(temp.name)
        with self.assertRaises(IOError):
            self.itol.add_file(' ')

    def test_good_upload(self):
        with patch('itolapi.Comm.upload_tree') as mock_upload:
            mock_upload.return_value = True
            self.itol.comm.tree_id = 1234
            self.assertEqual(self.itol.upload(), 1234)

    def test_bad_upload(self):
        with patch('itolapi.Comm.upload_tree') as mock_upload:
            mock_upload.return_value = False
            self.itol.comm.tree_id = 1234
            self.assertEqual(self.itol.upload(), 0)

    def test_get_webpage(self):
        self.itol.comm.tree_id = 'asdf'
        webpage = self.itol.get_webpage()
        self.assertIn('itol.embl.de', webpage)
        self.assertIn('asdf', webpage)

    def test_get_itol_export(self):
        self.itol.comm.tree_id = 1234
        export = self.itol.get_itol_export()
        self.assertEqual(export.params['tree'], 1234)

    @patch('itolapi.itol.pprint.pprint')
    def test_print_variables(self, mock_print):
        self.itol.params['treeName'] = 'test'
        with tempfile.NamedTemporaryFile() as temp:
            self.itol.add_file(temp.name)
            self.itol.print_variables()
        self.assertEqual(mock_print.call_args_list[0][0][0], self.itol.files)
        self.assertEqual(mock_print.call_args_list[1][0][0], self.itol.params)
Example #6
0
def plot(output_dir: str, table: biom.Table, tree: NewickFormat,
         feature_metadata: pd.DataFrame, category: str,
         color_palette: str = 'Dark2', ms2_label: bool = False,
         parent_mz: str = None) -> None:

    if category not in feature_metadata.columns:
        raise ValueError('Could not find %s in the feature data, the available'
                         ' columns are: %s.' %
                         (category,
                          ', '.join(feature_metadata.columns.astype())))

    color_fp = join(output_dir, 'colors.tsv')
    with open(color_fp, 'w') as fh:
        fh.write(format_colors(feature_metadata, category, color_palette))

    label_fp = join(output_dir, 'labels.tsv')
    with open(label_fp, 'w') as fh:
        fh.write(format_labels(feature_metadata, category, ms2_label,
                               parent_mz))

    # itol won't accept a file unless it has a .tree or .txt extension
    target = join(output_dir, 'qemistree.tree')
    copyfile(str(tree), target)

    # upload the tree, labels and tip coloring files
    itol_uploader = Itol()
    itol_uploader.add_file(target)
    itol_uploader.add_file(label_fp)
    itol_uploader.add_file(color_fp)

    status = itol_uploader.upload()

    if not status:
        raise ValueError(itol_uploader.comm.upload_output)

    url = itol_uploader.get_webpage()
    print(url)

    index_path = join(TEMPLATES, 'index.html')
    q2templates.render(index_path, output_dir, context={'url': url})
Example #7
0
print(
    ('Uploading the tree.  This may take some time depending on how large the '
     'tree is and how much load there is on the itol server'))
good_upload = test.upload()
if not good_upload:
    print('There was an error:' + test.comm.upload_output)
    sys.exit(1)

# Read the tree ID
print('Tree ID: ' + str(test.comm.tree_id))

# Read the iTOL API return statement
print('iTOL output: ' + str(test.comm.upload_output))

# Website to be redirected to iTOL tree
print('Tree Web Page URL: ' + test.get_webpage())

# Warnings associated with the upload
print('Warnings: ' + str(test.comm.warnings))

# Export a pre-made tree to pdf
#itol_exporter = ItolExport()
#itol_exporter.set_export_param_value('tree', '18793532031912684633930')
#itol_exporter.set_export_param_value('format', 'pdf')
#itol_exporter.set_export_param_value('datasetList', 'dataset1')
# itol_exporter.export('example_pdf.pdf')
# print('exported tree to ',export_location)

# Export the tree above to pdf
print('Exporting to pdf')
itol_exporter = test.get_itol_export()
Example #8
0
def Itol_Tree_m0(pfamid, datapath, outpath):#{{{
#Create the Itol class
    itl = Itol()
#Set the tree file
    tree = datapath + os.sep + pfamid + '.tree'
    (datafile1, datafile2, datafile3, datafile4) = ("", "", "", "")
    if not os.path.exists(tree):
        print("tree file %s does not exist. Ignore" %(tree), file=sys.stderr)
        return 1
    t = Tree(tree)
    leaves = t.get_leaves()
    numLeave = len(leaves)

    fontsize = GetFontSize(numLeave)

    datafile1 = datapath + os.sep + pfamid + '.numTM_and_io.txt'
#    datafile2 = datapath + os.sep + pfamid + '.cmpclass.colordef.txt'
#    datafile3 = datapath + os.sep + pfamid + '.ntermstate.colordef.txt'
    datafile4 = datapath + os.sep + pfamid + '.cluster.colordef.txt'

    colordeffile = datapath + os.sep + pfamid + '.pfam.colordef.txt'
    branchlabelfile = datapath + os.sep + pfamid + '.branchlabel.txt'

    datafileList = [datafile1, datafile2, datafile3, datafile4, colordeffile, branchlabelfile]

    rootname = os.path.basename(os.path.splitext(tree)[0])

#===================================
    itl.add_file(tree)
    itl.params['treeName'] = rootname
    itl.params['treeFormat'] = 'newick'

    valid_datafileList = []
    for datafile in datafileList:
        if os.path.exists(datafile):
            itl.add_file(datafile)
            valid_datafileList.append(datafile)
    datasets_list = [str(x) for x in range(len(valid_datafileList))]
# Check parameters
# itl.print_variables()

#Submit the tree
    print('')
    print('Uploading the tree.  This may take some time depending on how large the tree is and how much load there is on the itol server')
    good_upload = itl.upload()
    if good_upload == False:
        print('There was an error:'+itl.comm.upload_output)
        sys.exit(1)

#Read the tree ID
    print('Tree ID: '+str(itl.comm.tree_id))

#Read the iTOL API return statement
    print('iTOL output: '+str(itl.comm.upload_output))

#Website to be redirected to iTOL tree
    print('Tree Web Page URL: '+itl.get_webpage())

# Warnings associated with the upload
    print('Warnings: '+str(itl.comm.warnings))

#Export to pdf
    print('Exporting to pdf')
    itol_exporter = itl.get_itol_export()
#itol_exporter = itolexport.ItolExport()
#itol_exporter.set_export_param_value('tree','18793532031912684633930')
    itol_exporter.set_export_param_value('format', 'pdf')
    itol_exporter.set_export_param_value('display_mode',"2")
    #itol_exporter.set_export_param_value('current_font_size',fontsize)
    itol_exporter.set_export_param_value('align_labels',"1")
    itol_exporter.set_export_param_value('datasets_visible',",".join(datasets_list))

    epsfile = outpath + os.sep + pfamid + '-itol.eps'
    pdffile = outpath + os.sep + pfamid + '-itol.pdf'
    jpgfile = outpath + os.sep + pfamid + '-itol.jpg'
    thumbfile = outpath + os.sep + "thumb." + pfamid + '-itol.jpg'
    itol_exporter.export(pdffile)
    #os.system("epstopdf %s" % epsfile )
    os.system("convert %s %s" % (pdffile, jpgfile) )
    os.system("convert -thumbnail 200 %s %s" % (jpgfile, thumbfile))
    print('exported tree to ',pdffile)
Example #9
0
def Itol_Tree_m_sd3(pfamid, datapath, outpath):#{{{
    """Phylogenetic tree with species definition
    the Kindom use branch colordefinition, and others using color strips
    """
    tree = datapath + os.sep + pfamid + '.tree'
    t = Tree(tree)
    leaves = t.get_leaves()
    lst_leaves_name = []
    for leaf in leaves:
        lst_leaves_name.append(leaf.name)
    numLeave = len(lst_leaves_name)
    leaves_name_set = set(lst_leaves_name)

# read species definition
    speciesfile = "%s/%s.species"%(datapath, pfamid)
    speciesDict = myfunc.Read_species_sd(speciesfile)

# create branch color definition file for kingdom
    lst_kingdom = ["Archaea","Bacteria", "Eukaryota" ]
    lst_color_kingdom = ["#ff0000", "#0066ff","#cc6600"]
    species_colordef_file = "%s/%s.kingdom.colordef.txt"%(outpath, pfamid)
    color_dict_kingdom = {}
    this_speciesDict = {}
    for seqid in speciesDict:
        speciesname = speciesDict[seqid][0]
        this_speciesDict[seqid] = speciesname
    for i in range(len(lst_kingdom)):
        idd = lst_kingdom[i]
        color_dict_kingdom[idd] = lst_color_kingdom[i]
    myfunc.WriteKingdomColorDefFile(species_colordef_file, this_speciesDict, leaves_name_set, color_dict_kingdom)

# generate the next three levels of classification
    for level in [1,2,3]:
        outfile = "%s/%s.species.level_%d.txt"%(outpath, pfamid, level)
        this_speciesDict = {}
        speciesIDSet = set([])
        for seqid in speciesDict:
            try:
                speciesname = speciesDict[seqid][level]
                speciesIDSet.add(speciesname)
                this_speciesDict[seqid] = speciesname
            except IndexError as KeyError:
                pass
        color_dict = {}
        lst_color = list(blue.range_to(red,len(speciesIDSet)))
        lst_speciesID = list(speciesIDSet)
        for i in range(len(lst_speciesID)):
            idd = lst_speciesID[i]
            color_dict[idd] = lst_color[i].get_hex_l()
        myfunc.WriteSpeciesColorStripDefFile(outfile, this_speciesDict, leaves_name_set, color_dict)

#Create the Itol class
    itl = Itol()
#Set the tree file
    (datafile1, datafile2, datafile3, datafile4) = ("", "", "", "")
    if not os.path.exists(tree):
        print("tree file %s does not exist. Ignore" %(tree), file=sys.stderr)
        return 1

    fontsize = GetFontSize(numLeave)

    datafile1 = "%s/%s.species.level_%d.txt"%(outpath, pfamid, 1)
    datafile2 = "%s/%s.species.level_%d.txt"%(outpath, pfamid, 2)
    datafile3 = "%s/%s.species.level_%d.txt"%(outpath, pfamid, 3)
    colordeffile = species_colordef_file

    if os.path.exists(colordeffile):
        itl.add_variable('colorDefinitionFile', colordeffile)
        itl.add_variable('colorDefinitionLabel', "Kingdom")

#===================================
    itl.add_variable('treeFile',tree)
    itl.add_variable('treeName','SD3')
    itl.add_variable('treeFormat','newick')
#===================================
    if os.path.exists(datafile1):
        itl.add_variable('datafile1File',datafile1)
        itl.add_variable('datafile1Label','Phylum')
        itl.add_variable('datafile1Separator','comma')
        itl.add_variable('datafile1Type','colorstrip')
        itl.add_variable('datafile1StripWidth','100')
        itl.add_variable('datafile1ColoringType','both')
        itl.add_variable('datafile1PreventOverlap','1')
#===================================
    if os.path.exists(datafile2):
        itl.add_variable('datafile2File',datafile2)
        itl.add_variable('datafile2Label','Class')
        itl.add_variable('datafile2Separator','comma')
        itl.add_variable('datafile2Type','colorstrip')
        itl.add_variable('datafile2StripWidth','100')
        itl.add_variable('datafile2ColoringType','both')
        itl.add_variable('datafile2PreventOverlap','1')
#===================================
    if os.path.exists(datafile3):
        itl.add_variable('datafile3File',datafile3)
        itl.add_variable('datafile3Label','Order')
        itl.add_variable('datafile3Separator','comma')
        itl.add_variable('datafile3Type','colorstrip')
        itl.add_variable('datafile3StripWidth','100')
        itl.add_variable('datafile3ColoringType','both')
        itl.add_variable('datafile3PreventOverlap','1')
#===================================
# Check parameters
# itl.print_variables()

#Submit the tree
    print('')
    print('Uploading the tree.  This may take some time depending on how large the tree is and how much load there is on the itol server')
    good_upload = itl.upload()
    if good_upload == False:
        print('There was an error:'+itl.comm.upload_output)
        sys.exit(1)

#Read the tree ID
    print('Tree ID: '+str(itl.comm.tree_id))

#Read the iTOL API return statement
    print('iTOL output: '+str(itl.comm.upload_output))

#Website to be redirected to iTOL tree
    print('Tree Web Page URL: '+itl.get_webpage())

# Warnings associated with the upload
    print('Warnings: '+str(itl.comm.warnings))

#Export to pdf
    itol_exporter = itl.get_itol_export()
#itol_exporter = itolexport.ItolExport()
#itol_exporter.set_export_param_value('tree','18793532031912684633930')
    itol_exporter.set_export_param_value('format', 'eps')
    itol_exporter.set_export_param_value('display_mode',"2")
    itol_exporter.set_export_param_value('current_font_size',fontsize)
    itol_exporter.set_export_param_value('align_labels',"1")
    itol_exporter.set_export_param_value('datafileList','dataset1')
    extname = "-itol-sd3"
    epsfile = outpath + os.sep + pfamid + extname + '.eps'
    pdffile = outpath + os.sep + pfamid + extname + '.pdf'
    jpgfile = outpath + os.sep + pfamid + extname + '.jpg'
    pngfile = outpath + os.sep + pfamid + extname + '.png'
    thumbfile = outpath + os.sep + "thumb." + pfamid + extname + '.jpg'
    itol_exporter.export(epsfile)
    os.system("epstopdf %s" % epsfile )
    os.system("convert %s %s" % (epsfile, jpgfile) )
    os.system("convert -thumbnail 200 %s %s" % (jpgfile, thumbfile))
    print('exported tree to ',pdffile)
Example #10
0
def Itol_Tree_m_sd2(pfamid, datapath, outpath):#{{{
    tree = datapath + os.sep + pfamid + '.tree'
    t = Tree(tree)
    leaves = t.get_leaves()
    lst_leaves_name = []
    for leaf in leaves:
        lst_leaves_name.append(leaf.name)
    numLeave = len(lst_leaves_name)
    leaves_name_set = set(lst_leaves_name)
# read seqlen file
    seqlenfile = "%s/%s.seqlen.txt"%(datapath, pfamid)
    seqlen_dict = myfunc.ReadSeqLengthDict(seqlenfile)

# read subfamily definition
    domain_idlist = []
    domainfile = "%s/%s.mdp"%(datapath, pfamid)
    domain_dict = myfunc.Read_domain_sd(domainfile, domain_idlist)
    domain_colordef_file = "%s/%s.mdp.colordef.txt"%(datapath, pfamid)
    WriteDomainColorDefFile(domain_colordef_file, domain_dict, domain_idlist, seqlen_dict, leaves_name_set)

#Create the Itol class
    itl = Itol()
#Set the tree file
    (datafile1, datafile2, datafile3, datafile4) = ("", "", "", "")
    if not os.path.exists(tree):
        print("tree file %s does not exist. Ignore" %(tree), file=sys.stderr)
        return 1

    fontsize = GetFontSize(numLeave)

    datafile1 = domain_colordef_file
#     colordeffile = subfam_colordef_file
#     if os.path.exists(colordeffile):
#         itl.add_variable('colorDefinitionFile', colordeffile)
#         itl.add_variable('colorDefinitionLabel', "Subfamilies")
#===================================
    itl.add_variable('treeFile',tree)
    itl.add_variable('treeName','SD2')
    itl.add_variable('treeFormat','newick')
#===================================
    if os.path.exists(datafile1):
        itl.add_variable('datafile1File',datafile1)
        itl.add_variable('datafile1Label','Domain architecture')
        itl.add_variable('datafile1Separator','comma')
        itl.add_variable('datafile1Type','domains')
        itl.add_variable('datafile1ProtSizeMax','1000')
        itl.add_variable('datafile1PreventOverlap','1')
        itl.add_variable('datafile1CirclesSpacing','100')
#===================================
# Check parameters
# itl.print_variables()

#Submit the tree
    print('')
    print('Uploading the tree.  This may take some time depending on how large the tree is and how much load there is on the itol server')
    good_upload = itl.upload()
    if good_upload == False:
        print('There was an error:'+itl.comm.upload_output)
        sys.exit(1)

#Read the tree ID
    print('Tree ID: '+str(itl.comm.tree_id))

#Read the iTOL API return statement
    print('iTOL output: '+str(itl.comm.upload_output))

#Website to be redirected to iTOL tree
    print('Tree Web Page URL: '+itl.get_webpage())

# Warnings associated with the upload
    print('Warnings: '+str(itl.comm.warnings))

#Export to pdf
    itol_exporter = itl.get_itol_export()
#itol_exporter = itolexport.ItolExport()
#itol_exporter.set_export_param_value('tree','18793532031912684633930')
    itol_exporter.set_export_param_value('format', 'eps')
    itol_exporter.set_export_param_value('display_mode',"2")
    itol_exporter.set_export_param_value('current_font_size',fontsize)
    itol_exporter.set_export_param_value('align_labels',"1")
    itol_exporter.set_export_param_value('datafileList','dataset1')
    extname = "-itol-sd2"
    epsfile = outpath + os.sep + pfamid + extname + '.eps'
    pdffile = outpath + os.sep + pfamid + extname + '.pdf'
    jpgfile = outpath + os.sep + pfamid + extname + '.jpg'
    pngfile = outpath + os.sep + pfamid + extname + '.png'
    thumbfile = outpath + os.sep + "thumb." + pfamid + extname + '.jpg'
    itol_exporter.export(epsfile)
    os.system("epstopdf %s" % epsfile )
    os.system("convert %s %s" % (epsfile, jpgfile) )
    os.system("convert -thumbnail 200 %s %s" % (jpgfile, thumbfile))
    print('exported tree to ',pdffile)
Example #11
0
def Itol_Tree_m_sd1(pfamid, datapath, outpath):#{{{
    """Phylogenetic tree with numTM_io and subfamilies branch coloring
    """
    tree = datapath + os.sep + pfamid + '.tree'
    t = Tree(tree)
    leaves = t.get_leaves()
    lst_leaves_name = []
    for leaf in leaves:
        lst_leaves_name.append(leaf.name)
    numLeave = len(lst_leaves_name)
# read subfamily definition
    subfamfile = "%s/%s.subfamilies"%(datapath, pfamid)
    subfam_idlist = []
    subfamDict = myfunc.Read_subfamily(subfamfile, subfam_idlist)
    numSubFam = len(subfam_idlist)

# create subfamily branch color definition file
    subfam_colordef_file = "%s/%s.subfamilies.colordef.txt"%(outpath, pfamid)
    lst_color = list(blue.range_to(red,numSubFam))
    color_dict = {}
    for i in range(numSubFam):
        famid = subfam_idlist[i]
        color = lst_color[i].get_hex_l()
        color_dict[famid] = lst_color[i].get_hex_l()
    myfunc.WriteSubFamColorDef(subfam_colordef_file, subfamDict, lst_leaves_name, color_dict)

#Create the Itol class
    itl = Itol()
#Set the tree file
    (datafile1, datafile2, datafile3, datafile4) = ("", "", "", "")
    if not os.path.exists(tree):
        print("tree file %s does not exist. Ignore" %(tree), file=sys.stderr)
        return 1

    fontsize = GetFontSize(numLeave)

    datafile1 = datapath + os.sep + pfamid + '.numTM_and_io.txt'
    colordeffile = subfam_colordef_file

    if os.path.exists(colordeffile):
        itl.add_variable('colorDefinitionFile', colordeffile)
        itl.add_variable('colorDefinitionLabel', "Subfamilies")

#===================================
    itl.add_variable('treeFile',tree)
    itl.add_variable('treeName','SD1')
    itl.add_variable('treeFormat','newick')
#===================================
    if os.path.exists(datafile1):
        itl.add_variable('datafile1File',datafile1)
        itl.add_variable('datafile1Label','numTM_and_io')
        itl.add_variable('datafile1Separator','comma')
        itl.add_variable('datafile1Type','multibar')
        itl.add_variable('datafile1PreventOverlap','1')
        itl.add_variable('datafile1Color','#FF0000')
#===================================
# Check parameters
# itl.print_variables()

#Submit the tree
    print('')
    print('Uploading the tree.  This may take some time depending on how large the tree is and how much load there is on the itol server')
    good_upload = itl.upload()
    if good_upload == False:
        print('There was an error:'+itl.comm.upload_output)
        sys.exit(1)

#Read the tree ID
    print('Tree ID: '+str(itl.comm.tree_id))

#Read the iTOL API return statement
    print('iTOL output: '+str(itl.comm.upload_output))

#Website to be redirected to iTOL tree
    print('Tree Web Page URL: '+itl.get_webpage())

# Warnings associated with the upload
    print('Warnings: '+str(itl.comm.warnings))

#Export to pdf
    itol_exporter = itl.get_itol_export()
#itol_exporter = itolexport.ItolExport()
#itol_exporter.set_export_param_value('tree','18793532031912684633930')
    itol_exporter.set_export_param_value('format', 'eps')
    itol_exporter.set_export_param_value('display_mode',"2")
    itol_exporter.set_export_param_value('current_font_size',fontsize)
    itol_exporter.set_export_param_value('align_labels',"1")
    itol_exporter.set_export_param_value('datafileList','dataset1')
    extname = "-itol-sd1"
    epsfile = outpath + os.sep + pfamid + extname + '.eps'
    pdffile = outpath + os.sep + pfamid + extname + '.pdf'
    jpgfile = outpath + os.sep + pfamid + extname + '.jpg'
    pngfile = outpath + os.sep + pfamid + extname + '.png'
    thumbfile = outpath + os.sep + "thumb." + pfamid + extname + '.jpg'
    itol_exporter.export(epsfile)
    os.system("epstopdf %s" % epsfile )
    os.system("convert %s %s" % (epsfile, jpgfile) )
    os.system("convert -thumbnail 200 %s %s" % (jpgfile, thumbfile))
    print('exported tree to ',pdffile)
Example #12
0
def Itol_Tree_m1(pfamid, datapath, outpath):#{{{
# TM helices are treated as domains
#Create the Itol class
    itl = Itol()
#Set the tree file
    tree = datapath + os.sep + pfamid + '.tree'
    (datafile1, datafile2, datafile3, datafile4) = ("", "", "", "")
    if not os.path.exists(tree):
        print("tree file %s does not exist. Ignore" %(tree), file=sys.stderr)
        return 1
    t = Tree(tree)
    leaves = t.get_leaves()
    numLeave = len(leaves)

    fontsize = GetFontSize(numLeave)

    datafile1 = datapath + os.sep + pfamid + '.numTM_and_io.txt'
    datafile2 = datapath + os.sep + pfamid + '.cmpclass.colordef.txt'
#    datafile3 = datapath + os.sep + pfamid + '.ntermstate.colordef.txt'
    datafile4 = datapath + os.sep + pfamid + '.cluster.colordef.txt'

    colordeffile = datapath + os.sep + pfamid + '.pfam.colordef.txt'
    branchlabelfile = datapath + os.sep + pfamid + '.branchlabel.txt'

#===================================
    itl.add_variable('treeFile',tree)
    itl.add_variable('treeName','PF00854')
    itl.add_variable('treeFormat','newick')
    if os.path.exists(colordeffile):
        itl.add_variable('colorDefinitionFile', colordeffile)
    if os.path.exists(branchlabelfile):
        itl.add_variable('branchLabelsFile', branchlabelfile)

#===================================
    if os.path.exists(datafile1):
        itl.add_variable('datafile1File',datafile1)
        itl.add_variable('datafile1Label','numTM_and_io')
        itl.add_variable('datafile1Separator','comma')
        itl.add_variable('datafile1Type','multibar')
        itl.add_variable('datafile1PreventOverlap','1')
        itl.add_variable('datafile1Color','#FF0000')

#===================================
    if os.path.exists(datafile2):
        itl.add_variable('datafile2File', datafile2)
        itl.add_variable('datafile2Label', 'cmpclass')
        itl.add_variable('datafile2Separator','comma')
        itl.add_variable('datafile2Type','colorstrip')
        itl.add_variable('datafile2StripWidth','200')
        itl.add_variable('datafile2PreventOverlap','1')
        itl.add_variable('datafile2ColoringType','both')

#===================================
    if os.path.exists(datafile3):
        itl.add_variable('datafile3File', datafile3)
        itl.add_variable('datafile3Label', 'NtermState')
        itl.add_variable('datafile3Separator','comma')
        itl.add_variable('datafile3Type','colorstrip')
        itl.add_variable('datafile3StripWidth','200')
        itl.add_variable('datafile3PreventOverlap','1')
        itl.add_variable('datafile3ColoringType','both')

#===================================
    if os.path.exists(datafile4):
        itl.add_variable('datafile4File', datafile4)
        itl.add_variable('datafile4Label', 'cluster')
        itl.add_variable('datafile4Separator','comma')
        itl.add_variable('datafile4Type','colorstrip')
        itl.add_variable('datafile4StripWidth','200')
        itl.add_variable('datafile4PreventOverlap','1')
        itl.add_variable('datafile4ColoringType','both')
        itl.add_variable('datafile4BranchColoringType','both')
        
#itl.add_variable('datafile1BarSizeMax','1')

#===================================
# Check parameters
# itl.print_variables()


#Submit the tree
    print('')
    print('Uploading the tree.  This may take some time depending on how large the tree is and how much load there is on the itol server')
    good_upload = itl.upload()
    if good_upload == False:
        print('There was an error:'+itl.comm.upload_output)
        sys.exit(1)

#Read the tree ID
    print('Tree ID: '+str(itl.comm.tree_id))

#Read the iTOL API return statement
    print('iTOL output: '+str(itl.comm.upload_output))

#Website to be redirected to iTOL tree
    print('Tree Web Page URL: '+itl.get_webpage())

# Warnings associated with the upload
    print('Warnings: '+str(itl.comm.warnings))

#Export to pdf
    print('Exporting to pdf')
    itol_exporter = itl.get_itol_export()
#itol_exporter = itolexport.ItolExport()
#itol_exporter.set_export_param_value('tree','18793532031912684633930')
    itol_exporter.set_export_param_value('format', 'eps')
    itol_exporter.set_export_param_value('display_mode',"2")
    itol_exporter.set_export_param_value('current_font_size',fontsize)
    itol_exporter.set_export_param_value('align_labels',"1")
    itol_exporter.set_export_param_value('datafileList','dataset1')
    epsfile = outpath + os.sep + pfamid + '-itol.eps'
    pdffile = outpath + os.sep + pfamid + '-itol.pdf'
    jpgfile = outpath + os.sep + pfamid + '-itol.jpg'
    thumbfile = outpath + os.sep + "thumb." + pfamid + '-itol.jpg'
    itol_exporter.export(epsfile)
    os.system("epstopdf %s" % epsfile )
    os.system("convert %s %s" % (epsfile, jpgfile) )
    os.system("convert -thumbnail 200 %s %s" % (jpgfile, thumbfile))
    print('exported tree to ',pdffile)
Example #13
0
def upload_and_export_itol(
    cassiopeia_tree: CassiopeiaTree,
    tree_name: str,
    export_filepath: str,
    itol_config: str = "~/.itolconfig",
    api_key: Optional[str] = None,
    project_name: Optional[str] = None,
    meta_data: List[str] = [],
    allele_table: Optional[pd.DataFrame] = None,
    indel_colors: Optional[pd.DataFrame] = None,
    indel_priors: Optional[pd.DataFrame] = None,
    rect: bool = False,
    include_legend: bool = False,
    use_branch_lengths: bool = False,
    palette: List[str] = palettes.Category20[20],
    random_state: Optional[np.random.RandomState] = None,
    user_dataset_files: Optional[List[str]] = None,
    verbose: bool = True,
    **kwargs,
):
    """Uploads a tree to iTOL and exports it.

    This function takes in a tree, plots it with iTOL, and exports it locally.
    A user can also specify meta data and allele tables to visualize alongside
    their tree. The function requires a user to have an account with iTOL and
    can pass these credentials to the function in one of two ways: first, the
    user can specify an `api_key` and a `project_name`, which corresponds to one
    in the user's iTOL account' second, the user can have a hidden `itolconfig`
    file that can store these credentials (the default location we will check
    is in ~/.itolconfig, though this can be overridden by the user). We
    preferentially take values passed in explicitly to the function in the
    `api_key` and `project_name` arguments.

    TODO(mgjones): Add the ability to pass in min/max colors for specific
        numeric meta data to use when creating the gradient files.

    Args:
        cassiopeia_tree: A CassiopeiaTree instance, populated with a tree.
        tree_name: Name of the tree. This is what the tree will be called
            within your project directory on iTOL
        export_filepath: Output file path to save your tree. Must end with
            one of the following suffixes: ['png', 'svg', 'eps', 'ps', 'pdf'].
        itol_config: A configuration file that a user can maintain for storing
            iTOL account details (specifically, an API key and a project name
            for uploading trees). We assume that the information is stored under
            the [DEFAULT] header. We also will be default check the path
            `~/itolconfig` but the user can pass in another path should they
            wish. If an `api_key` and `project_name` are also passed in, we
            will preferentially take those values.
        api_key: API key linking to your iTOL account
        project_name: Project name to upload to.
        meta_data: Meta data to plot alongside the tree, which must be columns
            in the CassiopeiaTree.cell_meta variable.
        allele_table: Alleletable to plot alongside the tree.
        indel_colors: Color mapping to use for plotting the alleles for each
            cell. Only necessary if `allele_table` is specified.
        indel_priors: Prior probabilities for each indel. Only useful if an
            allele table is to be plotted and `indel_colors` is None.
        rect: Boolean indicating whether or not to save your tree as a circle
            or rectangle.
        use_branch_lengths: Whether or not to use branch lengths when exporting
            the tree.
        include_legend: Plot legend along with meta data.
        palette: A palette of colors in hex format.
        random_state: A random state for reproducibility
        user_dataset_files: List of paths to additional dataset files to upload.
            See https://itol.embl.de/help.cgi#dsType for available dataset types
            and their definitions.
        verbose: Include extra print statements.
        **kwargs: additional keyword arguments are passed as iTOL export parameters.
            See https://itol.embl.de/help.cgi#batch for a full list.

    Raises:
        iTOLError if iTOL credentials cannot be found, if the output format is
            not supported, if meta data to be plotted cannot be found, or if
            an error with iTOL is encountered.
    """

    # create temporary directory for storing files we'll upload to iTOL
    temporary_directory = tempfile.mkdtemp()

    if api_key is None or project_name is None:
        if os.path.exists(os.path.expanduser(itol_config)):

            config = configparser.ConfigParser()
            with open(os.path.expanduser(itol_config), "r") as f:
                config_string = f.read()
            config.read_string(config_string)

            try:
                api_key = config["DEFAULT"]["api_key"]
                project_name = config["DEFAULT"]["project_name"]
            except KeyError:
                raise iTOLError(
                    "Error reading the itol config file passed in.")

        else:
            raise iTOLError(
                "Specify an api_key and project_name, or a valid iTOL "
                "config file.")

    with open(os.path.join(temporary_directory, "tree_to_plot.tree"),
              "w") as f:
        f.write(cassiopeia_tree.get_newick(record_branch_lengths=True))

    file_format = export_filepath.split("/")[-1].split(".")[-1]

    if file_format not in ["png", "svg", "eps", "ps", "pdf"]:
        raise iTOLError("File format must be one of "
                        "'png', 'svg', 'eps', 'ps', 'pdf']")

    itol_uploader = Itol()
    itol_uploader.add_file(
        os.path.join(temporary_directory, "tree_to_plot.tree"))

    files = user_dataset_files.copy() if user_dataset_files else []
    if allele_table is not None:
        files += create_indel_heatmap(
            allele_table,
            cassiopeia_tree,
            f"{tree_name}.allele",
            temporary_directory,
            indel_colors,
            indel_priors,
            random_state,
        )

    for meta_item in meta_data:
        if meta_item not in cassiopeia_tree.cell_meta.columns:
            raise iTOLError("Meta data item not in CassiopeiaTree cell meta.")

        values = cassiopeia_tree.cell_meta[meta_item]

        if pd.api.types.is_numeric_dtype(values):
            files.append(
                create_gradient_from_df(
                    values,
                    cassiopeia_tree,
                    f"{tree_name}.{meta_item}",
                    temporary_directory,
                ))

        if pd.api.types.is_string_dtype(values):
            colors = palette[:len(values.unique())]
            colors = [utilities.hex_to_rgb(color) for color in colors]
            colormap = dict(zip(np.unique(values), colors))

            files.append(
                create_colorbar(
                    values,
                    cassiopeia_tree,
                    colormap,
                    f"{tree_name}.{meta_item}",
                    temporary_directory,
                    create_legend=include_legend,
                ))

    for _file in files:
        itol_uploader.add_file(_file)

    itol_uploader.params["treeName"] = tree_name
    itol_uploader.params["APIkey"] = api_key
    itol_uploader.params["projectName"] = project_name

    good_upload = itol_uploader.upload()
    if not good_upload:
        raise iTOLError(itol_uploader.comm.upload_output)

    if verbose:
        print("iTOL output: " + str(itol_uploader.comm.upload_output))
        print("Tree Web Page URL: " + itol_uploader.get_webpage())
        print("Warnings: " + str(itol_uploader.comm.warnings))

    tree_id = itol_uploader.comm.tree_id

    itol_exporter = ItolExport()

    # set parameters:
    itol_exporter.set_export_param_value("tree", tree_id)
    itol_exporter.set_export_param_value("format", file_format)
    if rect:
        # rectangular tree settings
        itol_exporter.set_export_param_value("display_mode", 1)
    else:
        # circular tree settings
        itol_exporter.set_export_param_value("display_mode", 2)
        itol_exporter.set_export_param_value("arc", 359)
        itol_exporter.set_export_param_value("rotation", 270)

    itol_exporter.set_export_param_value("leaf_sorting", 1)
    itol_exporter.set_export_param_value("label_display", 0)
    itol_exporter.set_export_param_value("internal_marks", 0)
    itol_exporter.set_export_param_value("ignore_branch_length",
                                         1 - int(use_branch_lengths))

    itol_exporter.set_export_param_value(
        "datasets_visible", ",".join([str(i) for i in range(len(files))]))

    itol_exporter.set_export_param_value("horizontal_scale_factor", 1)

    for key, value in kwargs.items():
        itol_exporter.set_export_param_value(key, value)

    # export!
    itol_exporter.export(export_filepath)

    # remove intermediate files
    shutil.rmtree(temporary_directory)
Example #14
0
def upload_to_itol(
    tree,
    apiKey,
    projectName,
    tree_name="test",
    files=[],
    outfp="test.pdf",
    fformat=None,
    rect=False,
    **kwargs,
):

    _leaves = tree.get_leaf_names()
    tree.write(outfile="tree_to_plot.tree", format=1)

    if fformat is None:
        fformat = outfp.split(".")[-1]

    itol_uploader = Itol()
    itol_uploader.add_file("tree_to_plot.tree")

    for file in files:
        itol_uploader.add_file(file)

    itol_uploader.params["treeName"] = tree_name
    itol_uploader.params["APIkey"] = apiKey
    itol_uploader.params["projectName"] = projectName

    good_upload = itol_uploader.upload()
    if not good_upload:
        print("There was an error:" + itol_uploader.comm.upload_output)
    print("iTOL output: " + str(itol_uploader.comm.upload_output))
    print("Tree Web Page URL: " + itol_uploader.get_webpage())
    print("Warnings: " + str(itol_uploader.comm.warnings))

    tree_id = itol_uploader.comm.tree_id

    itol_exporter = ItolExport()

    # set parameters:
    itol_exporter.set_export_param_value("tree", tree_id)
    itol_exporter.set_export_param_value(
        "format",
        outfp.split(
            ".")[-1])  # ['png', 'svg', 'eps', 'ps', 'pdf', 'nexus', 'newick']
    if rect:
        itol_exporter.set_export_param_value("display_mode",
                                             1)  # rectangular tree
    else:
        itol_exporter.set_export_param_value("display_mode",
                                             2)  # circular tree
        itol_exporter.set_export_param_value("arc", 359)
        itol_exporter.set_export_param_value("rotation", 270)

    itol_exporter.set_export_param_value("leaf_sorting", 1)
    itol_exporter.set_export_param_value("label_display", 1)
    itol_exporter.set_export_param_value("internal_marks", 1)
    itol_exporter.set_export_param_value("ignore_branch_length", 1)

    itol_exporter.set_export_param_value(
        "datasets_visible", ",".join([str(i) for i in range(len(files))]))

    itol_exporter.set_export_param_value(
        "horizontal_scale_factor", 1)  # doesnt actually scale the artboard

    # export!
    itol_exporter.export(outfp)

    os.remove("tree_to_plot.tree")
Example #15
0
def plot(output_dir: str,
         tree: NewickFormat,
         feature_metadata: pd.DataFrame,
         category: str = 'class',
         ms2_label: bool = False,
         color_palette: str = 'Dark2',
         parent_mz: bool = True,
         grouped_table: biom.Table = None,
         normalize_features: bool = True) -> None:
    '''This function plots the phenetic tree in iTOL with clade colors,
    feature labels and relative abundance per sample group.

    Parameters
    ----------
    tree : NewickFormat
        Phenetic tree
    feature_metadata : pd.DataFrame
        Feature metadata
    grouped_table : biom.Table, optional
        Feature table of samples grouped by categories
    category : str, optional
        The feature data column used to color and label the tips.
        Default 'class'
    color_palette : str, optional
        The color palette to use for coloring tips
    ms2_label : bool, optional
        Whether to label the tips with the MS2 value
    parent_mz : bool, optional
        If the feature is unclassified, label the tips using parent mass of
        compound
    normalize_features : bool, optional
        If True (default), the feature abundances are normalized to
        a constant sum i.e converted to relative abundances

    Raises
    ------
    ValueError
        If `category` is not a column in `feature_metadata`
    UserWarning
        If the number of unique values in `category` is greater than the number
        of unique colors in `color_palette`

    Returns
    -------
    None
    '''

    if category not in feature_metadata.columns:
        raise ValueError(
            'Could not find %s in the feature data, the available'
            ' columns are: %s.' %
            (category, ', '.join(feature_metadata.columns.astype())))

    color_fp = join(output_dir, 'colors')
    with open(color_fp, 'w') as fh:
        fh.write(format_colors(feature_metadata, category, color_palette))

    label_fp = join(output_dir, 'labels')
    with open(label_fp, 'w') as fh:
        fh.write(
            format_labels(feature_metadata, category, ms2_label, parent_mz))

    # itol won't accept a tree file unless it has a .tree or .txt extension
    target = join(output_dir, 'qemistree.tree')
    copyfile(str(tree), target)

    # upload the tree, labels and tip coloring files
    itol_uploader = Itol()
    itol_uploader.add_file(target)
    itol_uploader.add_file(label_fp)
    itol_uploader.add_file(color_fp)
    if grouped_table is not None:
        barplot_fp = join(output_dir, 'barplots')
        with open(barplot_fp, 'w') as fh:
            fh.write(format_barplots(grouped_table, normalize_features))
        itol_uploader.add_file(barplot_fp)

    status = itol_uploader.upload()

    if not status:
        raise ValueError(itol_uploader.comm.upload_output)

    url = itol_uploader.get_webpage()
    print(url)

    index_path = join(TEMPLATES, 'index.html')
    q2templates.render(index_path,
                       output_dir,
                       context={
                           'url': url,
                           'has_barplots': grouped_table is not None
                       })
Example #16
0
    'Uploading the tree.  This may take some time depending on how large the '
    'tree is and how much load there is on the itol server'
))
good_upload = test.upload()
if not good_upload:
    print('There was an error:' + test.comm.upload_output)
    sys.exit(1)

# Read the tree ID
print('Tree ID: ' + str(test.comm.tree_id))

# Read the iTOL API return statement
print('iTOL output: ' + str(test.comm.upload_output))

# Website to be redirected to iTOL tree
print('Tree Web Page URL: ' + test.get_webpage())

# Warnings associated with the upload
print('Warnings: ' + str(test.comm.warnings))


# Export a pre-made tree to pdf
itol_exporter = ItolExport()
itol_exporter.set_export_param_value('tree', '18793532031912684633930')
itol_exporter.set_export_param_value('format', 'pdf')
itol_exporter.set_export_param_value('datasetList', 'dataset1')
# itol_exporter.export('example_pdf.pdf')
# print('exported tree to ',export_location)

# Export the tree above to pdf
print('Exporting to pdf')
# Submit the tree
print('')
print(
    ('Uploading the tree.  This may take some time depending on how large the '
     'tree is and how much load there is on the itol server'))
good_upload = boom.upload()
if not good_upload:
    print('There was an error:' + boom.comm.upload_output)
    sys.exit(1)

# Read the tree ID
print('Tree ID: ' + str(boom.comm.tree_id))

# Read the iTOL API return statement
print('iTOL output: ' + str(boom.comm.upload_output))

# Website to be redirected to iTOL tree
print('Tree Web Page URL: ' + boom.get_webpage())

# Warnings associated with the upload
print('Warnings: ' + str(boom.comm.warnings))

# Export the tree to pdf
print('Exporting to pdf')
itol_exporter = boom.get_itol_export()
export_location = os.path.join(current_dir, 'MERS_CoV.pdf')
itol_exporter.set_export_param_value('format', 'pdf')
itol_exporter.set_export_param_value('datasetList', 'dataset1')
itol_exporter.export(export_location)
print('exported tree to ', export_location)