def align_two_alignments(aln1, aln2, moltype, params=None):
"""Returns an Alignment object from two existing Alignments.
aln1, aln2: cogent.core.alignment.Alignment objects, or data that can be
used to build them.
params: dict of parameters to pass in to the Clustal app controller.
"""
#create SequenceCollection object from seqs
aln1 = Alignment(aln1, MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
aln1_int_map, aln1_int_keys = aln1.getIntMap()
#Create SequenceCollection from int_map.
aln1_int_map = Alignment(aln1_int_map, MolType=moltype)
#create Alignment object from aln
aln2 = Alignment(aln2, MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
aln2_int_map, aln2_int_keys = aln2.getIntMap(prefix='seqn_')
#Create SequenceCollection from int_map.
aln2_int_map = Alignment(aln2_int_map, MolType=moltype)
#Update aln1_int_keys with aln2_int_keys
aln1_int_keys.update(aln2_int_keys)
#Create Mafft app.
app = Clustalw(InputHandler='_input_as_multiline_string',\
params=params,
SuppressStderr=True)
app.Parameters['-align'].off()
app.Parameters['-infile'].off()
app.Parameters['-profile'].on()
#Add aln_int_map as profile1
app.Parameters['-profile1'].on(\
app._tempfile_as_multiline_string(aln1_int_map.toFasta()))
#Add seq_int_map as profile2
app.Parameters['-profile2'].on(\
app._tempfile_as_multiline_string(aln2_int_map.toFasta()))
#Get results using int_map as input to app
res = app()
#Get alignment as dict out of results
alignment = dict(ClustalParser(res['Align'].readlines()))
#Make new dict mapping original IDs
new_alignment = {}
for k, v in alignment.items():
new_alignment[aln1_int_keys[k]] = v
#Create an Alignment object from alignment dict
new_alignment = Alignment(new_alignment, MolType=moltype)
#Clean up
res.cleanUp()
remove(app.Parameters['-profile1'].Value)
remove(app.Parameters['-profile2'].Value)
del(aln1,aln1_int_map,aln1_int_keys,\
aln2,aln2_int_map,aln2_int_keys,app,res,alignment)
return new_alignment
def align_two_alignments(aln1, aln2, moltype, params=None):
"""Returns an Alignment object from two existing Alignments.
aln1, aln2: cogent.core.alignment.Alignment objects, or data that can be
used to build them.
- Mafft profile alignment only works with aligned sequences. Alignment
object used to handle unaligned sequences.
params: dict of parameters to pass in to the Mafft app controller.
"""
#create SequenceCollection object from seqs
aln1 = Alignment(aln1,MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
aln1_int_map, aln1_int_keys = aln1.getIntMap()
#Create SequenceCollection from int_map.
aln1_int_map = Alignment(aln1_int_map,MolType=moltype)
#create Alignment object from aln
aln2 = Alignment(aln2,MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
aln2_int_map, aln2_int_keys = aln2.getIntMap(prefix='seqn_')
#Create SequenceCollection from int_map.
aln2_int_map = Alignment(aln2_int_map,MolType=moltype)
#Update aln1_int_keys with aln2_int_keys
aln1_int_keys.update(aln2_int_keys)
#Create Mafft app.
app = Mafft(InputHandler='_input_as_paths',\
params=params,
SuppressStderr=False)
app._command = 'mafft-profile'
aln1_path = app._tempfile_as_multiline_string(aln1_int_map.toFasta())
aln2_path = app._tempfile_as_multiline_string(aln2_int_map.toFasta())
filepaths = [aln1_path,aln2_path]
#Get results using int_map as input to app
res = app(filepaths)
#Get alignment as dict out of results
alignment = dict(MinimalFastaParser(res['StdOut'].readlines()))
#Make new dict mapping original IDs
new_alignment = {}
for k,v in list(alignment.items()):
key = k.replace('_seed_','')
new_alignment[aln1_int_keys[key]]=v
#Create an Alignment object from alignment dict
new_alignment = Alignment(new_alignment,MolType=moltype)
#Clean up
res.cleanUp()
remove(aln1_path)
remove(aln2_path)
remove('pre')
remove('trace')
del(aln1,aln1_int_map,aln1_int_keys,\
aln2,aln2_int_map,aln2_int_keys,app,res,alignment)
return new_alignment
def align_two_alignments(aln1, aln2, moltype, params=None):
"""Returns an Alignment object from two existing Alignments.
aln1, aln2: cogent.core.alignment.Alignment objects, or data that can be
used to build them.
- Mafft profile alignment only works with aligned sequences. Alignment
object used to handle unaligned sequences.
params: dict of parameters to pass in to the Mafft app controller.
"""
#create SequenceCollection object from seqs
aln1 = Alignment(aln1,MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
aln1_int_map, aln1_int_keys = aln1.getIntMap()
#Create SequenceCollection from int_map.
aln1_int_map = Alignment(aln1_int_map,MolType=moltype)
#create Alignment object from aln
aln2 = Alignment(aln2,MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
aln2_int_map, aln2_int_keys = aln2.getIntMap(prefix='seqn_')
#Create SequenceCollection from int_map.
aln2_int_map = Alignment(aln2_int_map,MolType=moltype)
#Update aln1_int_keys with aln2_int_keys
aln1_int_keys.update(aln2_int_keys)
#Create Mafft app.
app = Mafft(InputHandler='_input_as_paths',\
params=params,
SuppressStderr=False)
app._command = 'mafft-profile'
aln1_path = app._tempfile_as_multiline_string(aln1_int_map.toFasta())
aln2_path = app._tempfile_as_multiline_string(aln2_int_map.toFasta())
filepaths = [aln1_path,aln2_path]
#Get results using int_map as input to app
res = app(filepaths)
#Get alignment as dict out of results
alignment = dict(parse_fasta(res['StdOut']))
#Make new dict mapping original IDs
new_alignment = {}
for k,v in alignment.items():
key = k.replace('_seed_','')
new_alignment[aln1_int_keys[key]]=v
#Create an Alignment object from alignment dict
new_alignment = Alignment(new_alignment,MolType=moltype)
#Clean up
res.cleanUp()
remove(aln1_path)
remove(aln2_path)
remove('pre')
remove('trace')
del(aln1,aln1_int_map,aln1_int_keys,\
aln2,aln2_int_map,aln2_int_keys,app,res,alignment)
return new_alignment
def align_two_alignments(aln1, aln2, moltype, params=None):
"""Returns an Alignment object from two existing Alignments.
aln1, aln2: cogent.core.alignment.Alignment objects, or data that can be
used to build them.
params: dict of parameters to pass in to the Clustal app controller.
"""
#create SequenceCollection object from seqs
aln1 = Alignment(aln1,MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
aln1_int_map, aln1_int_keys = aln1.getIntMap()
#Create SequenceCollection from int_map.
aln1_int_map = Alignment(aln1_int_map,MolType=moltype)
#create Alignment object from aln
aln2 = Alignment(aln2,MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
aln2_int_map, aln2_int_keys = aln2.getIntMap(prefix='seqn_')
#Create SequenceCollection from int_map.
aln2_int_map = Alignment(aln2_int_map,MolType=moltype)
#Update aln1_int_keys with aln2_int_keys
aln1_int_keys.update(aln2_int_keys)
#Create Mafft app.
app = Clustalw(InputHandler='_input_as_multiline_string',\
params=params,
SuppressStderr=True)
app.Parameters['-align'].off()
app.Parameters['-infile'].off()
app.Parameters['-profile'].on()
#Add aln_int_map as profile1
app.Parameters['-profile1'].on(\
app._tempfile_as_multiline_string(aln1_int_map.toFasta()))
#Add seq_int_map as profile2
app.Parameters['-profile2'].on(\
app._tempfile_as_multiline_string(aln2_int_map.toFasta()))
#Get results using int_map as input to app
res = app()
#Get alignment as dict out of results
alignment = dict(ClustalParser(res['Align'].readlines()))
#Make new dict mapping original IDs
new_alignment = {}
for k,v in alignment.items():
new_alignment[aln1_int_keys[k]]=v
#Create an Alignment object from alignment dict
new_alignment = Alignment(new_alignment,MolType=moltype)
#Clean up
res.cleanUp()
remove(app.Parameters['-profile1'].Value)
remove(app.Parameters['-profile2'].Value)
del(aln1,aln1_int_map,aln1_int_keys,\
aln2,aln2_int_map,aln2_int_keys,app,res,alignment)
return new_alignment
def add_seqs_to_alignment(seqs, aln, moltype, params=None):
"""Returns an Alignment object from seqs and existing Alignment.
seqs: a cogent.core.alignment.SequenceCollection object, or data that can
be used to build one.
aln: a cogent.core.alignment.Alignment object, or data that can be used to
build one
params: dict of parameters to pass in to the Clustal app controller.
"""
# create SequenceCollection object from seqs
seq_collection = SequenceCollection(seqs, MolType=moltype)
# Create mapping between abbreviated IDs and full IDs
seq_int_map, seq_int_keys = seq_collection.getIntMap()
# Create SequenceCollection from int_map.
seq_int_map = SequenceCollection(seq_int_map, MolType=moltype)
# create Alignment object from aln
aln = Alignment(aln, MolType=moltype)
# Create mapping between abbreviated IDs and full IDs
aln_int_map, aln_int_keys = aln.getIntMap(prefix="seqn_")
# Create SequenceCollection from int_map.
aln_int_map = Alignment(aln_int_map, MolType=moltype)
# Update seq_int_keys with aln_int_keys
seq_int_keys.update(aln_int_keys)
# Create Mafft app.
app = Clustalw(InputHandler="_input_as_multiline_string", params=params, SuppressStderr=True)
app.Parameters["-align"].off()
app.Parameters["-infile"].off()
app.Parameters["-sequences"].on()
# Add aln_int_map as profile1
app.Parameters["-profile1"].on(app._tempfile_as_multiline_string(aln_int_map.toFasta()))
# Add seq_int_map as profile2
app.Parameters["-profile2"].on(app._tempfile_as_multiline_string(seq_int_map.toFasta()))
# Get results using int_map as input to app
res = app()
# Get alignment as dict out of results
alignment = dict(ClustalParser(res["Align"].readlines()))
# Make new dict mapping original IDs
new_alignment = {}
for k, v in alignment.items():
new_alignment[seq_int_keys[k]] = v
# Create an Alignment object from alignment dict
new_alignment = Alignment(new_alignment, MolType=moltype)
# Clean up
res.cleanUp()
remove(app.Parameters["-profile1"].Value)
remove(app.Parameters["-profile2"].Value)
del (seq_collection, seq_int_map, seq_int_keys, aln, aln_int_map, aln_int_keys, app, res, alignment)
return new_alignment
def dotur_from_alignment(aln,moltype,distance_function,params=None):
"""Returns dotur results given an alignment and distance function.
- aln: An Alignment object or something that behaves like one.
Sequences must be aligned.
- moltype: cogent.core.moltype object.
- distance_function: function that can be passed to distanceMatrix()
method of SequenceCollection. Must be able to find distance
between two sequences.
- NOTE: This function will only return the parsed *.list file, as
it contains the OTU identities.
Dotur generates 23 output files, so if this is not the one you
are looking for, check out the documentation and add the others
to the result path.
"""
#construct Alignment object. This will handle unaligned sequences.
aln = Alignment(aln, MolType=moltype)
#need to make int map.
int_map, int_keys = aln.getIntMap()
#construct Alignment object from int map to use object functionality
int_map = Alignment(int_map, MolType=moltype)
order = sorted(int_map.Names)
#Build distance matrix.
d_matrix_dict = int_map.distanceMatrix(f=distance_function)
d_matrix_dict.RowOrder=order
d_matrix_dict.ColOrder=order
#Get distance matrix in list form.
d_matrix_list = d_matrix_dict.toLists()
#must be strings to use phylipMatrix
for i,line in enumerate(d_matrix_list):
d_matrix_list[i]=map(str,line)
#Get phylip formatted string.
phylip_matrix_string = phylipMatrix(rows=d_matrix_list,names=order)
working_dir = get_tmp_filename(suffix='')
app = Dotur(InputHandler='_input_as_multiline_string',\
WorkingDir=working_dir,params=params)
res = app(phylip_matrix_string)
otu_list = OtuListParser(res['List'].readlines())
#remap sequence names
for i,otu in enumerate(otu_list):
otu_list[i][2]=remap_seq_names(otu[2], int_keys)
shutil.rmtree(app.WorkingDir)
return otu_list
def dotur_from_alignment(aln, moltype, distance_function, params=None):
"""Returns dotur results given an alignment and distance function.
- aln: An Alignment object or something that behaves like one.
Sequences must be aligned.
- moltype: cogent.core.moltype object.
- distance_function: function that can be passed to distanceMatrix()
method of SequenceCollection. Must be able to find distance
between two sequences.
- NOTE: This function will only return the parsed *.list file, as
it contains the OTU identities.
Dotur generates 23 output files, so if this is not the one you
are looking for, check out the documentation and add the others
to the result path.
"""
#construct Alignment object. This will handle unaligned sequences.
aln = Alignment(aln, MolType=moltype)
#need to make int map.
int_map, int_keys = aln.getIntMap()
#construct Alignment object from int map to use object functionality
int_map = Alignment(int_map, MolType=moltype)
order = sorted(int_map.Names)
#Build distance matrix.
d_matrix_dict = int_map.distanceMatrix(f=distance_function)
d_matrix_dict.RowOrder = order
d_matrix_dict.ColOrder = order
#Get distance matrix in list form.
d_matrix_list = d_matrix_dict.toLists()
#must be strings to use phylipMatrix
for i, line in enumerate(d_matrix_list):
d_matrix_list[i] = map(str, line)
#Get phylip formatted string.
phylip_matrix_string = phylipMatrix(rows=d_matrix_list, names=order)
working_dir = get_tmp_filename(suffix='')
app = Dotur(InputHandler='_input_as_multiline_string',\
WorkingDir=working_dir,params=params)
res = app(phylip_matrix_string)
otu_list = OtuListParser(res['List'].readlines())
#remap sequence names
for i, otu in enumerate(otu_list):
otu_list[i][2] = remap_seq_names(otu[2], int_keys)
shutil.rmtree(app.WorkingDir)
return otu_list
def rnaalifold_from_alignment(aln,moltype=RNA,params=None):
"""Returns seq, pairs, folding energy for alignment.
"""
#Create Alignment object. Object will handle if seqs are unaligned.
aln = Alignment(aln,MolType=RNA)
int_map, int_keys = aln.getIntMap()
app = RNAalifold(WorkingDir='/tmp',\
InputHandler='_input_as_multiline_string',params=params)
res = app(clustal_from_alignment(int_map))
#seq,pairs,energy = rnaalifold_parser(res['StdOut'].readlines())
pairs_list = MinimalRnaalifoldParser(res['StdOut'].readlines())
res.cleanUp()
return pairs_list
def rnaalifold_from_alignment(aln, moltype=RNA, params=None):
"""Returns seq, pairs, folding energy for alignment.
"""
#Create Alignment object. Object will handle if seqs are unaligned.
aln = Alignment(aln, MolType=RNA)
int_map, int_keys = aln.getIntMap()
app = RNAalifold(WorkingDir='/tmp',\
InputHandler='_input_as_multiline_string',params=params)
res = app(clustal_from_alignment(int_map))
#seq,pairs,energy = rnaalifold_parser(res['StdOut'].readlines())
pairs_list = MinimalRnaalifoldParser(res['StdOut'].readlines())
res.cleanUp()
return pairs_list
def build_tree_from_alignment(aln, moltype, best_tree=False, params={},\
working_dir='/tmp'):
"""Returns a tree from Alignment object aln.
aln: an cogent.core.alignment.Alignment object, or data that can be used
to build one.
- Clearcut only accepts aligned sequences. Alignment object used to
handle unaligned sequences.
moltype: a cogent.core.moltype object.
- NOTE: If moltype = RNA, we must convert to DNA since Clearcut v1.0.8
gives incorrect results if RNA is passed in. 'U' is treated as an
incorrect character and is excluded from distance calculations.
best_tree: if True (default:False), uses a slower but more accurate
algorithm to build the tree.
params: dict of parameters to pass in to the Clearcut app controller.
The result will be an cogent.core.tree.PhyloNode object, or None if tree
fails.
"""
params['--out'] = get_tmp_filename(working_dir)
# Create instance of app controller, enable tree, disable alignment
app = Clearcut(InputHandler='_input_as_multiline_string', params=params, \
WorkingDir=working_dir, SuppressStdout=True,\
SuppressStderr=True)
#Input is an alignment
app.Parameters['-a'].on()
#Turn off input as distance matrix
app.Parameters['-d'].off()
#If moltype = RNA, we must convert to DNA.
if moltype == RNA:
moltype = DNA
if best_tree:
app.Parameters['-N'].on()
#Turn on correct moltype
moltype_string = moltype.label.upper()
app.Parameters[MOLTYPE_MAP[moltype_string]].on()
# Setup mapping. Clearcut clips identifiers. We will need to remap them.
# Clearcut only accepts aligned sequences. Let Alignment object handle
# unaligned sequences.
seq_aln = Alignment(aln,MolType=moltype)
#get int mapping
int_map, int_keys = seq_aln.getIntMap()
#create new Alignment object with int_map
int_map = Alignment(int_map)
# Collect result
result = app(int_map.toFasta())
# Build tree
tree = DndParser(result['Tree'].read(), constructor=PhyloNode)
for node in tree.tips():
node.Name = int_keys[node.Name]
# Clean up
result.cleanUp()
del(seq_aln, app, result, int_map, int_keys, params)
return tree
def add_seqs_to_alignment(seqs, aln, moltype, params=None, accurate=False):
"""Returns an Alignment object from seqs and existing Alignment.
seqs: a cogent.core.sequence.Sequence object, or data that can be used
to build one.
aln: an cogent.core.alignment.Alignment object, or data that can be used
to build one
params: dict of parameters to pass in to the Mafft app controller.
"""
#create SequenceCollection object from seqs
seq_collection = SequenceCollection(seqs,MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
seq_int_map, seq_int_keys = seq_collection.getIntMap()
#Create SequenceCollection from int_map.
seq_int_map = SequenceCollection(seq_int_map,MolType=moltype)
#create Alignment object from aln
aln = Alignment(aln,MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
aln_int_map, aln_int_keys = aln.getIntMap(prefix='seqn_')
#Create SequenceCollection from int_map.
aln_int_map = Alignment(aln_int_map,MolType=moltype)
#Update seq_int_keys with aln_int_keys
seq_int_keys.update(aln_int_keys)
#Create Mafft app.
app = Mafft(InputHandler='_input_as_multiline_string',\
params=params,
SuppressStderr=True)
#Turn on correct moltype
moltype_string = moltype.label.upper()
app.Parameters[MOLTYPE_MAP[moltype_string]].on()
#Do not report progress
app.Parameters['--quiet'].on()
#Add aln_int_map as seed alignment
app.Parameters['--seed'].on(\
app._tempfile_as_multiline_string(aln_int_map.toFasta()))
#More accurate alignment, sacrificing performance.
if accurate:
app.Parameters['--globalpair'].on()
app.Parameters['--maxiterate'].Value=1000
#Get results using int_map as input to app
res = app(seq_int_map.toFasta())
#Get alignment as dict out of results
alignment = dict(MinimalFastaParser(res['StdOut'].readlines()))
#Make new dict mapping original IDs
new_alignment = {}
for k,v in list(alignment.items()):
key = k.replace('_seed_','')
new_alignment[seq_int_keys[key]]=v
#Create an Alignment object from alignment dict
new_alignment = Alignment(new_alignment,MolType=moltype)
#Clean up
res.cleanUp()
remove(app.Parameters['--seed'].Value)
del(seq_collection,seq_int_map,seq_int_keys,\
aln,aln_int_map,aln_int_keys,app,res,alignment)
return new_alignment
def add_seqs_to_alignment(seqs, aln, moltype, params=None, accurate=False):
"""Returns an Alignment object from seqs and existing Alignment.
seqs: a cogent.core.sequence.Sequence object, or data that can be used
to build one.
aln: an cogent.core.alignment.Alignment object, or data that can be used
to build one
params: dict of parameters to pass in to the Mafft app controller.
"""
#create SequenceCollection object from seqs
seq_collection = SequenceCollection(seqs,MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
seq_int_map, seq_int_keys = seq_collection.getIntMap()
#Create SequenceCollection from int_map.
seq_int_map = SequenceCollection(seq_int_map,MolType=moltype)
#create Alignment object from aln
aln = Alignment(aln,MolType=moltype)
#Create mapping between abbreviated IDs and full IDs
aln_int_map, aln_int_keys = aln.getIntMap(prefix='seqn_')
#Create SequenceCollection from int_map.
aln_int_map = Alignment(aln_int_map,MolType=moltype)
#Update seq_int_keys with aln_int_keys
seq_int_keys.update(aln_int_keys)
#Create Mafft app.
app = Mafft(InputHandler='_input_as_multiline_string',\
params=params,
SuppressStderr=True)
#Turn on correct moltype
moltype_string = moltype.label.upper()
app.Parameters[MOLTYPE_MAP[moltype_string]].on()
#Do not report progress
app.Parameters['--quiet'].on()
#Add aln_int_map as seed alignment
app.Parameters['--seed'].on(\
app._tempfile_as_multiline_string(aln_int_map.toFasta()))
#More accurate alignment, sacrificing performance.
if accurate:
app.Parameters['--globalpair'].on()
app.Parameters['--maxiterate'].Value=1000
#Get results using int_map as input to app
res = app(seq_int_map.toFasta())
#Get alignment as dict out of results
alignment = dict(parse_fasta(res['StdOut']))
#Make new dict mapping original IDs
new_alignment = {}
for k,v in alignment.items():
key = k.replace('_seed_','')
new_alignment[seq_int_keys[key]]=v
#Create an Alignment object from alignment dict
new_alignment = Alignment(new_alignment,MolType=moltype)
#Clean up
res.cleanUp()
remove(app.Parameters['--seed'].Value)
del(seq_collection,seq_int_map,seq_int_keys,\
aln,aln_int_map,aln_int_keys,app,res,alignment)
return new_alignment
def build_tree_from_alignment(aln, moltype, best_tree=False, params={},\
working_dir='/tmp'):
"""Returns a tree from Alignment object aln.
aln: an cogent.core.alignment.Alignment object, or data that can be used
to build one.
- Clearcut only accepts aligned sequences. Alignment object used to
handle unaligned sequences.
moltype: a cogent.core.moltype object.
- NOTE: If moltype = RNA, we must convert to DNA since Clearcut v1.0.8
gives incorrect results if RNA is passed in. 'U' is treated as an
incorrect character and is excluded from distance calculations.
best_tree: if True (default:False), uses a slower but more accurate
algorithm to build the tree.
params: dict of parameters to pass in to the Clearcut app controller.
The result will be an cogent.core.tree.PhyloNode object, or None if tree
fails.
"""
params['--out'] = get_tmp_filename(working_dir)
# Create instance of app controller, enable tree, disable alignment
app = Clearcut(InputHandler='_input_as_multiline_string', params=params, \
WorkingDir=working_dir, SuppressStdout=True,\
SuppressStderr=True)
#Input is an alignment
app.Parameters['-a'].on()
#Turn off input as distance matrix
app.Parameters['-d'].off()
#If moltype = RNA, we must convert to DNA.
if moltype == RNA:
moltype = DNA
if best_tree:
app.Parameters['-N'].on()
#Turn on correct moltype
moltype_string = moltype.label.upper()
app.Parameters[MOLTYPE_MAP[moltype_string]].on()
# Setup mapping. Clearcut clips identifiers. We will need to remap them.
# Clearcut only accepts aligned sequences. Let Alignment object handle
# unaligned sequences.
seq_aln = Alignment(aln, MolType=moltype)
#get int mapping
int_map, int_keys = seq_aln.getIntMap()
#create new Alignment object with int_map
int_map = Alignment(int_map)
# Collect result
result = app(int_map.toFasta())
# Build tree
tree = DndParser(result['Tree'].read(), constructor=PhyloNode)
for node in tree.tips():
node.Name = int_keys[node.Name]
# Clean up
result.cleanUp()
del (seq_aln, app, result, int_map, int_keys, params)
return tree
