Compare 1bed428 ... +15 ... 1acbdca

                dfm, outfilename=outfilename, title=filestem, params=params, args=args

                dfm, outfilename=outfilename, title=filestem, params=params, args=args

# TREEMETHODS = {}

    """Produce tree output for an analysis.

    :param args:  Namespace of command-line arguments

    This is graphical output for representing the ANI analysis results, and

    takes the form of a tree, or dendrogram.

    """

    # Announce what's going on to the user

    # Connect to database session

    # Parse output formats

    # Work on each run:

    run_id: int,

    session,

    outfmts: List[str],

    args: Namespace,

) -> None:

    """Write tree plots for each matrix type.

    :param run_id:  int, run_id for this run

    :param matdata:  MatrixData object for this distribution plot

    :param args:  Namespace for command-line arguments

    :param outfmts:  list of output formats for files

    """

        session.query(pyani_orm.Run).filter(pyani_orm.Run.run_id == run_id).first()

    )

        f"Have {len(result_label_dict)} labels and {len(result_class_dict)} classes"

    )

    # Create worker pool and empty command list

    # Build and collect the plotting commands

        MatrixData(*_)

        for _ in [

            ("identity", pd.read_json(results.df_identity), {}),

            ("coverage", pd.read_json(results.df_coverage), {}),

            ("aln_lengths", pd.read_json(results.df_alnlength), {}),

            ("sim_errors", pd.read_json(results.df_simerrors), {}),

            ("hadamard", pd.read_json(results.df_hadamard), {}),

        ]

        if _[0] in args.trees

    ]:

            (

                write_tree,

                [run_id, matdata, result_label_dict, result_class_dict, outfmts, args],

            )

        )

    # Run the plotting commands

    # Close worker pool

    run_id: int,

    matdata: MatrixData,

    result_labels: Dict,

    result_classes: Dict,

    outfmts: List[str],

    args: Namespace,

) -> None:

    """Write a single tree for a pyani run.

    :param run_id:  int, run_id for this run

    :param matdata:  MatrixData object for this heatmap

    :param result_labels:  dict of result labels

    :param result_classes: dict of result classes

    :param args:  Namespace for command-line arguments

    :param outfmts:  list of output formats for files

    """

    # logger = logging.getLogger(__name__)

            matdata.data,

            outfname,

            title=f"matrix_{matdata.name}_run{run_id}",

            params=params,

            format=fmt,

            args=args,

        )

    # If Newick strings were generated, write them out.

    """Label info for tree plots.

    :param fig:  a Seaborn clustermap instance

    :param axis:  one of {'row', 'col'}

    :param params:  plot parameters; this is where the labels come from

    """

            fig.dendrogram_col.reordered_ind, fig.ax_heatmap.get_yticklabels()

        ):

            fig.dendrogram_row.reordered_ind, fig.ax_heatmap.get_xticklabels()

        ):

    """Generates a newick formatted file from a tree,

    using recursion to traverse it.

    :param node:  a (portion of a) tree to be traversed

    :param parentdist:  distance from the parent node

    :param leaf_names:  lables that will be attached to the terminal nodes

    :param newick:  the current newick-formatted tree structure

    """

    # logger = logging.getLogger(__name__)

    # logger.debug(f"{type(parentdist)}, {parentdist}")

    # logger.debug(f"{type(node.dist)}, {node.dist}")

    else:

        else:

    """Generate a newick file and dendrogram plot for the given dataframe.

    :param dfr:  a dataframe

    # :param fig:  a figure produced by sns.clustermap

    :param title:  name of the matrix plot

    :param format:  image file format being used

    :param params:  matrix plot parameters; including labels

    :param args:  Namespace

    """

    # Get matrix name and run_id from the plot title

    # Add a colorbar?

    else:

    # Dictionary to allow abstraction over axes

        "columns": {

            "axis": fig.dendrogram_col,

            "names": dfr.columns,  # fig.dendrogram_col.reordered_ind,

        },

        "rows": {

            "axis": fig.dendrogram_row,

            "names": dfr.index,  # fig.dendrogram_row.reordered_ind,

        },

    }

    # Create a linkage dendrogram and newick string for both rows and columns

        # Generate newick format

        # Generate dendrogram

        # if 'dendrogram' in args.tree:

        # if args.tree:

        # figtree = ClusterTree(newick, text_array=matrix)

        # Write the tree to file

    # Return the newick strings so we can save them in the database (eventually)

    # Add taxonomy to nodes, and align to right

        # if node.name == "F962_00589":

        #     faces.add_face_to_node(

        #         AttrFace("name", fgcolor="white"),

        #         node,

        #         column=0,

        #         position="branch-right",

        #     )

        #     faces.add_face_to_node(

        #         AttrFace("species", fgcolor="white"), node, column=0, position="aligned"

        #     )

        #     node.img_style["bgcolor"] == "darkred"

        # else:

            AttrFace("name", fgcolor="black"),

            node,

            column=0,

            position="branch-right",

        )

    """Return `Genus species` (where known) for a node."""

# TMETHODS = {"seaborn": pyani_graphics.seaborn.}

            Path(args.outdir) / f"matrix_{matdata.name}_run{run_id}_{args.method}.{fmt}"

        )

            format=fmt,

            args=args,

    # If Newick strings were generated, add them to NEWICKS.

    # If Newick strings were generated, write them out.