Python Newick.parse方法代码示例

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_response_content(fs):
    # Read the newick trees.
    true_tree = Newick.parse(fs.true_tree, Newick.NewickTree)
    test_tree = Newick.parse(fs.test_tree, Newick.NewickTree)
    flags = get_flags(fs)
    # Get a list of maps from node id to harmonic extension.
    true_tree_leaf_ids = set(id(x) for x in true_tree.gen_tips())
    nleaves = len(true_tree_leaf_ids)
    id_to_full_val_list = [Harmonic.get_harmonic_valuations(
        true_tree, i) for i in range(1, nleaves)]
    id_map =  get_true_leaf_id_to_test_leaf_id(true_tree, test_tree)
    test_id_to_adj = get_id_to_adj(test_tree)
    test_id_to_name = get_id_to_name(test_tree)
    # Get the list of id to val maps with respect to leaf ids of the test tree.
    test_tree_internal_ids = set(id(x) for x in test_tree.gen_internal_nodes())
    test_tree_leaf_ids = set(id(x) for x in test_tree.gen_tips())
    id_to_val_list = []
    for id_to_full_val in id_to_full_val_list:
        d = {}
        for x in true_tree_leaf_ids:
            value = id_to_full_val[x]
            if abs(value) < 1e-8:
                raise ValueError('the true tree is too symmetric')
            elif value < 0:
                s = -1
            else:
                s = 1
            d[id_map[x]] = s
        for x in test_tree_internal_ids:
            d[x] = None
        id_to_val_list.append(d)
    # Attempt to find a sign assignment.
    id_to_vals = SeekEigenLacing.rec_eigen(
            test_id_to_adj, id_to_val_list, flags)
    # Reorder the leaf and the internal node ids according to name order.
    leaf_pair = sorted(
            (test_id_to_name[x], x) for x in test_tree_leaf_ids)
    internal_pair = sorted(
            (test_id_to_name[x], x) for x in test_tree_internal_ids)
    reordered_leaf_ids = zip(*leaf_pair)[1]
    reordered_internal_ids = zip(*internal_pair)[1]
    # Check for a failure to find a certificate.
    if not id_to_vals:
        return 'no non-rejection certificate was found'
    # Start writing the response.
    out = StringIO()
    print >> out, 'leaf sign valuations:'
    for x in reordered_leaf_ids:
        print >> out, test_id_to_name[x], get_sign_string(id_to_vals[x])
    print >> out
    print >> out, 'vertex sign compatible internal vertex valuations:'
    for x in reordered_internal_ids:
        print >> out, test_id_to_name[x], get_sign_string(id_to_vals[x])
    return out.getvalue()

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_response_content(fs):
    # get the tree
    tree = Newick.parse(fs.tree, Newick.NewickTree)
    tree.assert_valid()
    tree.add_branch_lengths()
    if tree.has_negative_branch_lengths():
        msg_a = 'calculating weights for a tree '
        msg_b = 'with negative branch lengths is not implemented'
        raise HandlingError(msg_a + msg_b)
    # get the selected names
    selection = Util.get_stripped_lines(fs.selection.splitlines())
    selected_name_set = set(selection)
    possible_name_set = set(node.get_name() for node in tree.gen_tips())
    extra_names = selected_name_set - possible_name_set
    if extra_names:
        msg_a = 'the following selected names are not valid tips: '
        msg_b = str(tuple(extra_names))
        raise HandlingError(msg_a + msg_b)
    # prune the tree 
    for name in set(node.name for node in tree.gen_tips()) - set(selection): 
        try: 
            node = tree.get_unique_node(name) 
        except NewickSearchError as e: 
            raise HandlingError(e) 
        tree.prune(node)
    # get the weights
    if fs.stone:
        name_weight_pairs = LeafWeights.get_stone_weights(tree)
    elif fs.thompson:
        name_weight_pairs = LeafWeights.get_thompson_weights(tree)
    # report the weights
    lines = ['%s: %f' % pair for pair in name_weight_pairs]
    return '\n'.join(lines) + '\n'

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_sample_tree():
    """
    @return: a mixture model that is used to generate the default nexus data
    """
    tree_string = '(((Human:0.1, Chimpanzee:0.2):0.8, Gorilla:0.3):0.7, Orangutan:0.4, Gibbon:0.5);'
    tree = Newick.parse(tree_string, Newick.NewickTree)
    return tree

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_response_content(fs):
    # get a properly formatted newick tree with branch lengths
    tree = Newick.parse(fs.tree, SpatialTree.SpatialTree)
    tree.assert_valid()
    if tree.has_negative_branch_lengths():
        msg = 'drawing a tree with negative branch lengths is not implemented'
        raise HandlingError(msg)
    tree.add_branch_lengths()
    # do the layout
    if fs.daylight:
        try:
            layout = FastDaylightLayout.StraightBranchLayout()
            layout.do_layout(tree)
        except RuntimeError as e:
            pass
    elif fs.curved:
        try:
            layout = FastDaylightLayout.CurvedBranchLayout()
            layout.set_min_segment_count(400)
            layout.do_layout(tree)
        except RuntimeError as e:
            pass
    elif fs.arc:
        EqualArcLayout.do_layout(tree)
    # draw the image
    try:
        ext = Form.g_imageformat_to_ext[fs.imageformat]
        return DrawTreeImage.get_tree_image(tree, (640, 480), ext)
    except CairoUtil.CairoUtilError as e:
        raise HandlingError(e)

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_form():
    """
    @return: the body of a form
    """
    # define the tree string
    tree_string = Newick.daylight_example_tree
    tree = Newick.parse(tree_string, Newick.NewickTree)
    formatted_tree_string = Newick.get_narrow_newick_string(tree, 60)
    # define the form objects
    form_objects = [
            Form.MultiLine('tree', 'newick tree', formatted_tree_string),
            Form.IntegerInterval(
                'first_index', 'last_index',
                'eigenfunction index range (1 means Fiedler)',
                0, 12, low=0),
            Form.CheckGroup('check_options', 'output options', [
                Form.CheckItem('reflect_trees', 'reflect trees', True),
                Form.CheckItem('draw_background', 'draw background', True),
                Form.CheckItem('draw_labels', 'draw labels', True)]),
            Form.Integer('width', 'physical width', 880, low=10, high=1000),
            Form.Integer('height', 'physical height', 680, low=10, high=1000),
            Form.Integer('inner_margin', 'inner margin', 10, low=0, high=1000),
            Form.Integer('outer_margin', 'outer margin', 0, low=0, high=1000),
            Form.ImageFormat()]
    return form_objects

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_form():
    """
    @return: the body of a form
    """
    # define the default tree string
    tree_string = Newick.brown_example_tree
    tree = Newick.parse(tree_string, Newick.NewickTree)
    formatted_tree_string = Newick.get_narrow_newick_string(tree, 60)
    # define the default alignment string
    default_alignment_string = Fasta.brown_example_alignment.strip()
    # define the default nucleotide distribution weights
    default_nt_lines = [
            'A : 1',
            'C : 1',
            'G : 1',
            'T : 1']
    # define the form objects
    form_objects = [
            Form.MultiLine('tree', 'newick tree', formatted_tree_string),
            Form.MultiLine('alignment', 'nucleotide alignment',
                default_alignment_string),
            Form.MultiLine('weights', 'nucleotide weights',
                '\n'.join(default_nt_lines)),
            Form.Float('kappa', 'transition transversion rate ratio',
                2, low_inclusive=0)]
    return form_objects

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_response_content(fs):
    # get the tree
    tree = Newick.parse(fs.tree, Newick.NewickTree)
    tree.assert_valid()
    # get the mixture weights
    weights = [fs.weight_a, fs.weight_b, fs.weight_c]
    # get the matrices
    matrices = [fs.matrix_a, fs.matrix_b, fs.matrix_c]
    for R in matrices:
        if R.shape != (4,4):
            msg = 'expected each nucleotide rate matrix to be 4x4'
            raise HandlingError(msg)
    # get the nucleotide alignment
    try:
        alignment = Fasta.Alignment(fs.alignment.splitlines())
        alignment.force_nucleotide()
    except Fasta.AlignmentError as e:
        raise HandlingError(e)
    # create the mixture proportions
    weight_sum = sum(weights)
    mixture_proportions = [weight / weight_sum for weight in weights]
    # create the rate matrix objects
    ordered_states = list('ACGT')
    rate_matrix_objects = []
    for R in matrices:
        rate_matrix_object = RateMatrix.RateMatrix(R.tolist(), ordered_states)
        rate_matrix_objects.append(rate_matrix_object)
    # create the mixture model
    mixture_model = SubModel.MixtureModel(mixture_proportions,
            rate_matrix_objects)
    # normalize the mixture model
    mixture_model.normalize()
    # return the html string
    return do_analysis(mixture_model, alignment, tree) + '\n'

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_form():
    """
    @return: the body of a form
    """
    # define the tree string
    tree_string = '(((Human:0.1, Chimpanzee:0.2):0.8, Gorilla:0.3):0.7, Orangutan:0.4, Gibbon:0.5);'
    tree = Newick.parse(tree_string, Newick.NewickTree)
    formatted_tree_string = Newick.get_narrow_newick_string(tree, 60)
    # define the form objects
    form_objects = [
            Form.MultiLine('tree', 'newick tree', formatted_tree_string),
            Form.Integer('ncols', 'sample this many nucleotide columns',
                100, low=1, high=1000),
            Form.MultiLine('frequency_a', 'first component frequencies',
                get_frequency_string(0)),
            Form.Float('kappa_a', 'first component kappa',
                get_kappa(0), low_inclusive=0),
            Form.Float('weight_a', 'first component weight',
                get_weight(0), low_inclusive=0),
            Form.MultiLine('frequency_b', 'second component frequencies',
                get_frequency_string(1)),
            Form.Float('kappa_b', 'second component kappa',
                get_kappa(1), low_inclusive=0),
            Form.Float('weight_b', 'second component weight',
                get_weight(1), low_inclusive=0),
            Form.RadioGroup('fmt', 'output format options', [
                Form.RadioItem('fasta', 'fasta'),
                Form.RadioItem('nex', 'nexus', True)])]
    return form_objects

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_test_image_format_and_string():
    import DrawTreeImage
    import Newick
    import SpatialTree
    # make a spatial tree
    tree_string = """
    ((((((((((((A:2)A:2, (B:2)B:2):3):3, (C:2.5)C:2.5):4):4, (D:3)D:3):1.5):1.5, (E:10.5)E:10.5):5):5, (((((F:2)F:2, (G:6)G:6):7):7, (H:4)H:4):6.5):6.5):6.5):6.5, (((((I:2.5)I:2.5, (J:1)J:1):15):15, (((K:5.5)K:5.5, (L:5.5)L:5.5):1):1):8.5):8.5, (M:28)M:28);"""
    tree = Newick.parse(tree_string, SpatialTree.SpatialTree)
    try:
        layout = EqualDaylightLayout()
        layout.force_straight_branches = False
        layout.do_layout(tree)
    except EqualDaylightLayoutError as e:
        print e
    # color some of the branches
    red = 'ff0000'
    green = '00ff00'
    blue = '0000ff'
    for child, color in zip(tree.root.children, (red, green, blue)):
        for node in child.preorder():
            node.branch_color = color
    # get the image string
    image_format = 'png'
    image_string = DrawTreeImage.get_tree_image(tree, (640, 480), image_format)
    return (image_format, image_string)

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_tikz_lines(newick, eigenvector_index, yaw, pitch):
    """
    @param eigenvector_index: 1 is Fiedler
    """
    tree = Newick.parse(newick, SpatialTree.SpatialTree) 
    # change the node names and get the new tree string
    for node in tree.preorder():
        node.name = 'n' + str(id(node))
    newick = NewickIO.get_newick_string(tree)
    # do the layout
    layout = FastDaylightLayout.StraightBranchLayout() 
    layout.do_layout(tree) 
    tree.fit((g_xy_scale, g_xy_scale))
    name_to_location = dict((
        x.name, tree._layout_to_display(x.location)) for x in tree.preorder())
    T, B, N = FtreeIO.newick_to_TBN(newick)
    # get some vertices
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    vertices = leaves + internal
    # get the locations
    v_to_location = dict((v, name_to_location[N[v]]) for v in vertices)
    # get the valuations
    w, V = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
    index_to_val = V[:, eigenvector_index-1]
    v_to_val = dict(
            (vertices[i], g_z_scale*val) for i, val in enumerate(index_to_val))
    # get the coordinates
    v_to_xyz = get_v_to_xyz(yaw, v_to_location, v_to_val)
    # add intersection vertices
    add_intersection_vertices(T, B, v_to_xyz)
    intersection_vertices = sorted(v for v in v_to_xyz if v not in vertices)
    # get lines of the tikz file
    return xyz_to_tikz_lines(T, B, pitch, v_to_xyz,
            leaves, internal, intersection_vertices)

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_form():
    """
    @return: the body of a form
    """
    # define the tree string
    tree_string = '(((Human:0.1, Chimpanzee:0.2):0.8, Gorilla:0.3):0.7, Orangutan:0.4, Gibbon:0.5);'
    tree = Newick.parse(tree_string, Newick.NewickTree)
    formatted_tree_string = Newick.get_narrow_newick_string(tree, 60)
    # define the form objects
    form_objects = [
            Form.MultiLine('tree', 'newick tree',
                formatted_tree_string),
            Form.MultiLine('alignment', 'nucleotide alignment',
                g_sample_alignment_string.strip()),
            Form.Matrix('matrix_a', 'first nucleotide rate matrix',
                g_nt_matrix_a),
            Form.Float('weight_a', 'first mixture weight',
                1, low_inclusive=0),
            Form.Matrix('matrix_b', 'second nucleotide rate matrix',
                g_nt_matrix_b),
            Form.Float('weight_b', 'second mixture weight',
                2, low_inclusive=0),
            Form.Matrix('matrix_c', 'third nucleotide rate matrix',
                g_nt_matrix_c),
            Form.Float('weight_c', 'third mixture weight',
                3, low_inclusive=0)]
    return form_objects

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_response_content(fs):
    # get a properly formatted newick tree with branch lengths
    tree_string = '((1:1, 2:1)6:1, 3:1, (4:1, 5:1)7:1)8;'
    tree = Newick.parse(tree_string, SpatialTree.SpatialTree)
    # get the fiedler-like vertex valuation
    fiedler = [1, 1, -1, -1, -1, 1, -1, -1]
    # create a node id map
    ids = [None]*8
    for node in tree.preorder():
        index = int(node.name) - 1
        ids[index] = id(node)
    # convert fiedler into a dictionary
    v1 = dict((ids[i], float(fiedler[i])) for i in range(8))
    # convert the annotations into dictionaries
    v2s = [dict((ids[i], float(v[i])) for i in range(8)) for v in g_annotation]
    # do the layout
    try:
        layout = FastDaylightLayout.StraightBranchLayout()
        layout.do_layout(tree)
    except RuntimeError as e:
        pass
    # draw the image
    try:
        ext = Form.g_imageformat_to_ext[fs.imageformat]
        return DrawEigenLacing.get_eg2_image(
                tree, (640, 480), ext,
                v1, v2s,
                fs.draw_background, fs.draw_vertices, fs.draw_labels)
    except CairoUtil.CairoUtilError as e:
        raise HandlingError(e)

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def make_file(newick_string, filename_prefix, iterations, min_segments):
    import DrawTreeImage
    import Newick
    import SpatialTree
    # make a spatial tree
    tree = Newick.parse(newick_string, SpatialTree.SpatialTree)
    # break the tree into pieces
    segment_tree(tree, min_segments, SpatialTree.SpatialTreeNode)
    print 'broke the tree into', sum(1 for node in tree.preorder()), 'nodes'
    # do the layout
    do_layout(tree, iterations)
    print 'did the layout'
    # color some of the branches
    red = 'ff0000'
    green = '00ff00'
    blue = '0000ff'
    for child, color in zip(tree.root.children, (red, green, blue)):
        for node in child.preorder():
            node.branch_color = color
    # get the image string
    image_format = 'png'
    image_string = DrawTreeImage.get_tree_image(tree, (640, 480), image_format)
    print 'created the image string'
    # write the image file
    with open('%s.%s' % (filename_prefix, image_format), 'wb') as fout:
        fout.write(image_string)

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_response_content(fs):
    # get the tree
    tree = Newick.parse(fs.tree, Newick.NewickTree)
    tree.assert_valid()
    # get the sequence order if it exists
    ordered_names = Util.get_stripped_lines(fs.order.splitlines())
    if ordered_names:
        observed_name_set = set(ordered_names)
        expected_name_set = set(node.get_name() for node in tree.gen_tips())
        extra_names = observed_name_set - expected_name_set
        missing_names = expected_name_set - observed_name_set
        if extra_names:
            msg_a = 'the list of ordered names includes these names '
            msg_b = 'not found in the tree: %s' % str(tuple(extra_names))
            raise HandlingError(msg_a + msg_b)
        if missing_names:
            msg_a = 'the tree includes these names not found in the list '
            msg_b = 'of ordered names: %s' % str(tuple(missing_names))
            raise HandlingError(msg_a + msg_b)
    else:
        ordered_names = list(tip.get_name() for name in tree.gen_tips())
    # do the sampling
    sampled_sequences = JC69.sample_sequences(tree, ordered_names, fs.length)
    alignment = Fasta.create_alignment(ordered_names, sampled_sequences)
    # return the response
    return alignment.to_fasta_string() + '\n'

# 需要导入模块: import Newick [as 别名]
# 或者: from Newick import parse [as 别名]
def get_form():
    """
    @return: the body of a form
    """
    # define the tree string
    tree = Newick.parse(g_tree_string, Newick.NewickTree)
    formatted_tree_string = Newick.get_narrow_newick_string(tree, 60)
    # define the default tip data lines
    default_tip_data_lines = [
            'a : A',
            'b : A',
            'c : C',
            'd : T',
            'e : T',
            'f : T']
    # define the default rate matrix lines
    R = np.array([
        [-1, 1/3.0, 1/3.0, 1/3.0],
        [1/3.0, -1, 1/3.0, 1/3.0],
        [1/3.0, 1/3.0, -1, 1/3.0],
        [1/3.0, 1/3.0, 1/3.0, -1]])
    # define the form objects
    form_objects = [
            Form.MultiLine('tree', 'newick tree', formatted_tree_string),
            Form.MultiLine('column', 'tip data',
                '\n'.join(default_tip_data_lines)),
            Form.Matrix('matrix', 'rate matrix',
                R, MatrixUtil.assert_rate_matrix),
            Form.ImageFormat()]
    return form_objects