skfolio 0.2.1__tar.gz → 0.2.3__tar.gz

{skfolio-0.2.1/src/skfolio.egg-info → skfolio-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skfolio
-Version: 0.2.1
+Version: 0.2.3
 Summary: Portfolio optimization built on top of scikit-learn
 Author-email: Hugo Delatte <delatte.hugo@gmail.com>
 Maintainer-email: Hugo Delatte <delatte.hugo@gmail.com>
@@ -56,13 +56,13 @@ Classifier: Topic :: Software Development
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: numpy>=1.23.4
+Requires-Dist: numpy<2.0.0,>=1.23.4
 Requires-Dist: scipy>=1.8.0
 Requires-Dist: pandas>=1.4.1
 Requires-Dist: cvxpy>=1.4.1
 Requires-Dist: scikit-learn>=1.3.2
 Requires-Dist: joblib>=1.3.2
-Requires-Dist: plotly>=5.15.0
+Requires-Dist: plotly>=5.22.0
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"

{skfolio-0.2.1 → skfolio-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skfolio"
-version = "0.2.1"
+version = "0.2.3"
 maintainers = [
     { name = "Hugo Delatte", email = "delatte.hugo@gmail.com" },
 ]
@@ -15,13 +15,13 @@ description = "Portfolio optimization built on top of scikit-learn"
 readme = "README.rst"
 requires-python = ">=3.10"
 dependencies = [
-    "numpy>=1.23.4",
+    "numpy>=1.23.4, <2.0.0", # TODO: remove "<2.0.0" when https://github.com/cvxpy/cvxpy/issues/2474 is completed
     "scipy>=1.8.0",
     "pandas>=1.4.1",
     "cvxpy>=1.4.1",
     "scikit-learn>=1.3.2",
     "joblib>=1.3.2",
-    "plotly>=5.15.0"
+    "plotly>=5.22.0"
 ]
 keywords = [
     "portfolio",

{skfolio-0.2.1 → skfolio-0.2.3}/src/skfolio/cluster/_hierarchical.py

@@ -13,8 +13,8 @@ import scipy.cluster.hierarchy as sch
 import scipy.spatial.distance as scd
 import sklearn.base as skb
 import sklearn.utils.validation as skv
+from plotly.figure_factory import create_dendrogram
 
-from skfolio.utils.fixes import create_dendrogram
 from skfolio.utils.stats import assert_is_distance, compute_optimal_n_clusters
 from skfolio.utils.tools import AutoEnum, default_asset_names
 

{skfolio-0.2.1 → skfolio-0.2.3}/src/skfolio/population/_population.py

@@ -20,8 +20,6 @@ from skfolio.portfolio import BasePortfolio, MultiPeriodPortfolio
 from skfolio.utils.sorting import non_denominated_sort
 from skfolio.utils.tools import deduplicate_names
 
-pd.options.plotting.backend = "plotly"
-
 
 class Population(list):
     """Population Class.
@@ -616,7 +614,7 @@ class Population(list):
         df = pd.concat(cumulative_returns, axis=1).iloc[:, idx]
         df.columns = deduplicate_names(names)
 
-        fig = df.plot()
+        fig = df.plot(backend="plotly")
         fig.update_layout(
             title=title,
             xaxis_title="Observations",

{skfolio-0.2.1 → skfolio-0.2.3}/src/skfolio/portfolio/_base.py

@@ -61,10 +61,6 @@ from skfolio.utils.tools import (
     format_measure,
 )
 
-# TODO: remove and use plotly express
-pd.options.plotting.backend = "plotly"
-
-
 _ZERO_THRESHOLD = 1e-5
 _MEASURES = {
     e for enu in [PerfMeasure, RiskMeasure, ExtraRiskMeasure, RatioMeasure] for e in enu
@@ -988,7 +984,7 @@ class BasePortfolio:
             yaxis_title = title
             title = f"{title} (non-compounded)"
 
-        fig = df.plot()
+        fig = df.plot(backend="plotly")
         fig.update_layout(
             title=title,
             xaxis_title="Observations",
@@ -1019,7 +1015,7 @@ class BasePortfolio:
         """
         if idx is None:
             idx = slice(None)
-        fig = self.returns_df.iloc[idx].plot()
+        fig = self.returns_df.iloc[idx].plot(backend="plotly")
         fig.update_layout(
             title="Returns",
             xaxis_title="Observations",
@@ -1050,7 +1046,7 @@ class BasePortfolio:
         """
         rolling = self.rolling_measure(measure=measure, window=window)
         rolling.name = f"{measure} {window} observations"
-        fig = rolling.plot()
+        fig = rolling.plot(backend="plotly")
         fig.add_hline(
             y=getattr(self, measure.value),
             line_width=1,

{skfolio-0.2.1 → skfolio-0.2.3}/src/skfolio/portfolio/_multi_period_portfolio.py

@@ -18,8 +18,6 @@ from skfolio.portfolio._base import BasePortfolio
 from skfolio.portfolio._portfolio import Portfolio
 from skfolio.utils.tools import deduplicate_names
 
-pd.options.plotting.backend = "plotly"
-
 
 class MultiPeriodPortfolio(BasePortfolio):
     r"""Multi-Period Portfolio class.

{skfolio-0.2.1 → skfolio-0.2.3}/src/skfolio/portfolio/_portfolio.py

@@ -26,8 +26,6 @@ from skfolio.utils.tools import (
     input_to_array,
 )
 
-pd.options.plotting.backend = "plotly"
-
 
 class Portfolio(BasePortfolio):
     r"""

{skfolio-0.2.1 → skfolio-0.2.3}/src/skfolio/preprocessing/_returns.py

@@ -4,6 +4,8 @@
 # Author: Hugo Delatte <delatte.hugo@gmail.com>
 # License: BSD 3 clause
 
+from typing import Literal
+
 import numpy as np
 import pandas as pd
 
@@ -13,7 +15,8 @@ def prices_to_returns(
     y: pd.DataFrame | None = None,
     log_returns: bool = False,
     nan_threshold: float = 1,
-    join: str = "outer",
+    join: Literal["left", "right", "inner", "outer", "cross"] = "outer",
+    drop_inceptions_nan: bool = True,
 ) -> pd.DataFrame | tuple[pd.DataFrame, pd.DataFrame]:
     r"""Transforms a DataFrame of prices to linear or logarithmic returns.
 
@@ -53,13 +56,19 @@ def prices_to_returns(
     log_returns : bool, default=True
         If this is set to True, logarithmic returns are used instead of simple returns.
 
-    join : str, default='outer
+    join : str, default="outer"
         The join method between `X` and `y` when `y` is provided.
 
     nan_threshold : float, default=1.0
         Drop observations (rows) that have a percentage of missing assets prices above
         this threshold. The default (`1.0`) is to keep all the observations.
 
+    drop_inceptions_nan : bool, default=True
+        If this is set to True, observations at the beginning are dropped if any of
+        the asset values are missing, otherwise we keep the NaNs. This is useful when
+        you work with a large universe of assets with different inception dates coupled
+        with a pre-selection Transformer.
+
     Returns
     -------
     X : DataFrame
@@ -82,7 +91,7 @@ def prices_to_returns(
     else:
         if not isinstance(y, pd.DataFrame):
             raise TypeError("`y` must be a DataFrame")
-        df = X.join(y, how="outer")
+        df = X.join(y, how=join)
 
     n_observations, n_assets = X.shape
 
@@ -98,18 +107,20 @@ def prices_to_returns(
 
     # Forward fill missing values
     df.ffill(inplace=True)
-    # Drop rows if any of its values is missing
-    df.dropna(axis=0, how="any", inplace=True)
+    # Drop rows according to drop_inceptions_nan
+    # noinspection PyTypeChecker
+    df.dropna(how="any" if drop_inceptions_nan else "all", inplace=True)
     # Drop column if all its values are missing
     df.dropna(axis=1, how="all", inplace=True)
 
     # returns
-    all_returns = df.pct_change().dropna()
+    all_returns = df.pct_change().iloc[1:]
     if log_returns:
         all_returns = np.log1p(all_returns)
 
     if y is None:
         return all_returns
+
     returns = all_returns[[x for x in X.columns if x in df.columns]]
     factor_returns = all_returns[[x for x in y.columns if x in df.columns]]
     return returns, factor_returns

{skfolio-0.2.1 → skfolio-0.2.3}/src/skfolio/utils/stats.py

@@ -448,7 +448,7 @@ def compute_optimal_n_clusters(distance: np.ndarray, linkage_matrix: np.ndarray)
     """
     cut_tree = sch.cut_tree(linkage_matrix)
     n = cut_tree.shape[1]
-    max_clusters = max(8, round(np.sqrt(n)))
+    max_clusters = min(n, max(8, round(np.sqrt(n))))
     dispersion = []
     for k in range(max_clusters):
         level = cut_tree[:, n - k - 1]

{skfolio-0.2.1 → skfolio-0.2.3/src/skfolio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skfolio
-Version: 0.2.1
+Version: 0.2.3
 Summary: Portfolio optimization built on top of scikit-learn
 Author-email: Hugo Delatte <delatte.hugo@gmail.com>
 Maintainer-email: Hugo Delatte <delatte.hugo@gmail.com>
@@ -56,13 +56,13 @@ Classifier: Topic :: Software Development
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: numpy>=1.23.4
+Requires-Dist: numpy<2.0.0,>=1.23.4
 Requires-Dist: scipy>=1.8.0
 Requires-Dist: pandas>=1.4.1
 Requires-Dist: cvxpy>=1.4.1
 Requires-Dist: scikit-learn>=1.3.2
 Requires-Dist: joblib>=1.3.2
-Requires-Dist: plotly>=5.15.0
+Requires-Dist: plotly>=5.22.0
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"

{skfolio-0.2.1 → skfolio-0.2.3}/src/skfolio.egg-info/SOURCES.txt

@@ -80,6 +80,4 @@ src/skfolio/utils/bootstrap.py
 src/skfolio/utils/equations.py
 src/skfolio/utils/sorting.py
 src/skfolio/utils/stats.py
-src/skfolio/utils/tools.py
-src/skfolio/utils/fixes/__init__.py
-src/skfolio/utils/fixes/_dendrogram.py
+src/skfolio/utils/tools.py

{skfolio-0.2.1 → skfolio-0.2.3}/src/skfolio.egg-info/requires.txt

@@ -1,10 +1,10 @@
-numpy>=1.23.4
+numpy<2.0.0,>=1.23.4
 scipy>=1.8.0
 pandas>=1.4.1
 cvxpy>=1.4.1
 scikit-learn>=1.3.2
 joblib>=1.3.2
-plotly>=5.15.0
+plotly>=5.22.0
 
 [docs]
 Sphinx

skfolio-0.2.1/src/skfolio/utils/fixes/__init__.py

@@ -1,3 +0,0 @@
-from skfolio.utils.fixes._dendrogram import create_dendrogram
-
-__all__ = ["create_dendrogram"]

skfolio-0.2.1/src/skfolio/utils/fixes/_dendrogram.py

@@ -1,391 +0,0 @@
-"""Compatibility fixes for plotly"""
-
-# Fixes of the create_dendrogram plotly function until
-# https://github.com/plotly/plotly.py/pull/4487 is corrected
-
-from collections import OrderedDict
-
-import numpy as np
-import scipy.cluster.hierarchy as sch
-import scipy.spatial as scs
-from plotly import exceptions
-from plotly.graph_objs import graph_objs
-
-
-def create_dendrogram(
-    X,
-    orientation="bottom",
-    labels=None,
-    colorscale=None,
-    distfun=None,
-    linkagefun=lambda x: sch.linkage(x, "complete"),
-    hovertext=None,
-    color_threshold=None,
-):
-    """
-    Function that returns a dendrogram Plotly figure object. This is a thin
-    wrapper around scipy.cluster.hierarchy.dendrogram.
-
-    See also https://dash.plot.ly/dash-bio/clustergram.
-
-    :param (ndarray) X: Matrix of observations as array of arrays
-    :param (str) orientation: 'top', 'right', 'bottom', or 'left'
-    :param (list) labels: List of axis category labels(observation labels)
-    :param (list) colorscale: Optional colorscale for the dendrogram tree.
-                              Requires 8 colors to be specified, the 7th of
-                              which is ignored.  With scipy>=1.5.0, the 2nd, 3rd
-                              and 6th are used twice as often as the others.
-                              Given a shorter list, the missing values are
-                              replaced with defaults and with a longer list the
-                              extra values are ignored.
-    :param (function) distfun: Function to compute the pairwise distance from
-                               the observations
-    :param (function) linkagefun: Function to compute the linkage matrix from
-                               the pairwise distances
-    :param (list[list]) hovertext: List of hovertext for constituent traces of dendrogram
-                               clusters
-    :param (double) color_threshold: Value at which the separation of clusters will be made
-
-    Example 1: Simple bottom oriented dendrogram
-
-    >>> from plotly.figure_factory import create_dendrogram
-
-    >>> import numpy as np
-
-    >>> X = np.random.rand(10,10)
-    >>> fig = create_dendrogram(X)
-    >>> fig.show()
-
-    Example 2: Dendrogram to put on the left of the heatmap
-
-    >>> from plotly.figure_factory import create_dendrogram
-
-    >>> import numpy as np
-
-    >>> X = np.random.rand(5,5)
-    >>> names = ['Jack', 'Oxana', 'John', 'Chelsea', 'Mark']
-    >>> dendro = create_dendrogram(X, orientation='right', labels=names)
-    >>> dendro.update_layout({'width':700, 'height':500}) # doctest: +SKIP
-    >>> dendro.show()
-
-    Example 3: Dendrogram with Pandas
-
-    >>> from plotly.figure_factory import create_dendrogram
-
-    >>> import numpy as np
-    >>> import pandas as pd
-
-    >>> Index= ['A','B','C','D','E','F','G','H','I','J']
-    >>> df = pd.DataFrame(abs(np.random.randn(10, 10)), index=Index)
-    >>> fig = create_dendrogram(df, labels=Index)
-    >>> fig.show()
-    """
-
-    s = X.shape
-    if len(s) != 2:
-        exceptions.PlotlyError("X should be 2-dimensional array.")
-
-    if distfun is None:
-        distfun = scs.distance.pdist
-
-    dendrogram = _Dendrogram(
-        X,
-        orientation,
-        labels,
-        colorscale,
-        distfun=distfun,
-        linkagefun=linkagefun,
-        hovertext=hovertext,
-        color_threshold=color_threshold,
-    )
-
-    return graph_objs.Figure(data=dendrogram.data, layout=dendrogram.layout)
-
-
-class _Dendrogram:
-    """Refer to FigureFactory.create_dendrogram() for docstring."""
-
-    def __init__(
-        self,
-        X,
-        orientation="bottom",
-        labels=None,
-        colorscale=None,
-        width=np.inf,
-        height=np.inf,
-        xaxis="xaxis",
-        yaxis="yaxis",
-        distfun=None,
-        linkagefun=lambda x: sch.linkage(x, "complete"),
-        hovertext=None,
-        color_threshold=None,
-    ):
-        self.orientation = orientation
-        self.labels = labels
-        self.xaxis = xaxis
-        self.yaxis = yaxis
-        self.data = []
-        self.leaves = []
-        self.sign = {self.xaxis: 1, self.yaxis: 1}
-        self.layout = {self.xaxis: {}, self.yaxis: {}}
-
-        if self.orientation in ["left", "bottom"]:
-            self.sign[self.xaxis] = 1
-        else:
-            self.sign[self.xaxis] = -1
-
-        if self.orientation in ["right", "bottom"]:
-            self.sign[self.yaxis] = 1
-        else:
-            self.sign[self.yaxis] = -1
-
-        if distfun is None:
-            distfun = scs.distance.pdist
-
-        (dd_traces, xvals, yvals, ordered_labels, leaves) = self.get_dendrogram_traces(
-            X, colorscale, distfun, linkagefun, hovertext, color_threshold
-        )
-
-        self.labels = ordered_labels
-        self.leaves = leaves
-        yvals_flat = yvals.flatten()
-        xvals_flat = xvals.flatten()
-
-        self.zero_vals = []
-
-        for i in range(len(yvals_flat)):
-            if yvals_flat[i] == 0.0 and xvals_flat[i] not in self.zero_vals:
-                self.zero_vals.append(xvals_flat[i])
-
-        if len(self.zero_vals) > len(yvals) + 1:
-            # If the length of zero_vals is larger than the length of yvals,
-            # it means that there are wrong vals because of the identicial samples.
-            # Three and more identicial samples will make the yvals of spliting
-            # center into 0 and it will accidentally take it as leaves.
-            l_border = int(min(self.zero_vals))
-            r_border = int(max(self.zero_vals))
-            correct_leaves_pos = range(
-                l_border, r_border + 1, int((r_border - l_border) / len(yvals))
-            )
-            # Regenerating the leaves pos from the self.zero_vals with equally intervals.
-            self.zero_vals = [v for v in correct_leaves_pos]
-
-        self.zero_vals.sort()
-        self.layout = self.set_figure_layout(width, height)
-        self.data = dd_traces
-
-    def get_color_dict(self, colorscale):
-        """
-        Returns colorscale used for dendrogram tree clusters.
-
-        :param (list) colorscale: Colors to use for the plot in rgb format.
-        :rtype (dict): A dict of default colors mapped to the user colorscale.
-
-        """
-
-        # These are the color codes returned for dendrograms
-        # We're replacing them with nicer colors
-        # This list is the colors that can be used by dendrogram, which were
-        # determined as the combination of the default above_threshold_color and
-        # the default color palette (see scipy/cluster/hierarchy.py)
-        d = {
-            "r": "red",
-            "g": "green",
-            "b": "blue",
-            "c": "cyan",
-            "m": "magenta",
-            "y": "yellow",
-            "k": "black",
-            # palette in scipy/cluster/hierarchy.py
-            "w": "white",
-        }
-        default_colors = OrderedDict(sorted(d.items(), key=lambda t: t[0]))
-
-        if colorscale is None:
-            rgb_colorscale = [
-                "rgb(0,116,217)",  # blue
-                "rgb(35,205,205)",  # cyan
-                "rgb(61,153,112)",  # green
-                "rgb(40,35,35)",  # black
-                "rgb(133,20,75)",  # magenta
-                "rgb(255,65,54)",  # red
-                "rgb(255,255,255)",  # white
-                "rgb(255,220,0)",  # yellow
-            ]
-        else:
-            rgb_colorscale = colorscale
-
-        for i in range(len(default_colors.keys())):
-            k = list(default_colors.keys())[i]  # PY3 won't index keys
-            if i < len(rgb_colorscale):
-                default_colors[k] = rgb_colorscale[i]
-
-        # add support for cyclic format colors as introduced in scipy===1.5.0
-        # before this, the colors were named 'r', 'b', 'y' etc., now they are
-        # named 'C0', 'C1', etc. To keep the colors consistent regardless of the
-        # scipy version, we try as much as possible to map the new colors to the
-        # old colors
-        # this mapping was found by inpecting scipy/cluster/hierarchy.py (see
-        # comment above).
-        new_old_color_map = [
-            ("C0", "b"),
-            ("C1", "g"),
-            ("C2", "r"),
-            ("C3", "c"),
-            ("C4", "m"),
-            ("C5", "y"),
-            ("C6", "k"),
-            ("C7", "g"),
-            ("C8", "r"),
-            ("C9", "c"),
-        ]
-        for nc, oc in new_old_color_map:
-            try:
-                default_colors[nc] = default_colors[oc]
-            except KeyError:
-                # it could happen that the old color isn't found (if a custom
-                # colorscale was specified), in this case we set it to an
-                # arbitrary default.
-                default_colors[nc] = "rgb(0,116,217)"
-
-        return default_colors
-
-    def set_axis_layout(self, axis_key):
-        """
-        Sets and returns default axis object for dendrogram figure.
-
-        :param (str) axis_key: E.g., 'xaxis', 'xaxis1', 'yaxis', yaxis1', etc.
-        :rtype (dict): An axis_key dictionary with set parameters.
-
-        """
-        axis_defaults = {
-            "type": "linear",
-            "ticks": "outside",
-            "mirror": "allticks",
-            "rangemode": "tozero",
-            "showticklabels": True,
-            "zeroline": False,
-            "showgrid": False,
-            "showline": True,
-        }
-
-        if len(self.labels) != 0:
-            axis_key_labels = self.xaxis
-            if self.orientation in ["left", "right"]:
-                axis_key_labels = self.yaxis
-            if axis_key_labels not in self.layout:
-                self.layout[axis_key_labels] = {}
-            self.layout[axis_key_labels]["tickvals"] = [
-                zv * self.sign[axis_key] for zv in self.zero_vals
-            ]
-            self.layout[axis_key_labels]["ticktext"] = self.labels
-            self.layout[axis_key_labels]["tickmode"] = "array"
-
-        self.layout[axis_key].update(axis_defaults)
-
-        return self.layout[axis_key]
-
-    def set_figure_layout(self, width, height):
-        """
-        Sets and returns default layout object for dendrogram figure.
-
-        """
-        self.layout.update(
-            {
-                "showlegend": False,
-                "autosize": False,
-                "hovermode": "closest",
-                "width": width,
-                "height": height,
-            }
-        )
-
-        self.set_axis_layout(self.xaxis)
-        self.set_axis_layout(self.yaxis)
-
-        return self.layout
-
-    def get_dendrogram_traces(
-        self, X, colorscale, distfun, linkagefun, hovertext, color_threshold
-    ):
-        """
-        Calculates all the elements needed for plotting a dendrogram.
-
-        :param (ndarray) X: Matrix of observations as array of arrays
-        :param (list) colorscale: Color scale for dendrogram tree clusters
-        :param (function) distfun: Function to compute the pairwise distance
-                                   from the observations
-        :param (function) linkagefun: Function to compute the linkage matrix
-                                      from the pairwise distances
-        :param (list) hovertext: List of hovertext for constituent traces of dendrogram
-        :rtype (tuple): Contains all the traces in the following order:
-            (a) trace_list: List of Plotly trace objects for dendrogram tree
-            (b) icoord: All X points of the dendrogram tree as array of arrays
-                with length 4
-            (c) dcoord: All Y points of the dendrogram tree as array of arrays
-                with length 4
-            (d) ordered_labels: leaf labels in the order they are going to
-                appear on the plot
-            (e) P['leaves']: left-to-right traversal of the leaves
-
-        """
-        d = distfun(X)
-        Z = linkagefun(d)
-        P = sch.dendrogram(
-            Z,
-            orientation=self.orientation,
-            labels=self.labels,
-            no_plot=True,
-            color_threshold=color_threshold,
-        )
-
-        icoord = np.array(P["icoord"])
-        dcoord = np.array(P["dcoord"])
-        ordered_labels = np.array(P["ivl"])
-        color_list = np.array(P["color_list"])
-        colors = self.get_color_dict(colorscale)
-
-        trace_list = []
-
-        for i in range(len(icoord)):
-            # xs and ys are arrays of 4 points that make up the '∩' shapes
-            # of the dendrogram tree
-            if self.orientation in ["top", "bottom"]:
-                xs = icoord[i]
-            else:
-                xs = dcoord[i]
-
-            if self.orientation in ["top", "bottom"]:
-                ys = dcoord[i]
-            else:
-                ys = icoord[i]
-            color_key = color_list[i]
-            hovertext_label = None
-            if hovertext:
-                hovertext_label = hovertext[i]
-            trace = dict(
-                type="scatter",
-                x=np.multiply(self.sign[self.xaxis], xs),
-                y=np.multiply(self.sign[self.yaxis], ys),
-                mode="lines",
-                marker=dict(color=colors[color_key]),
-                text=hovertext_label,
-                hoverinfo="text",
-            )
-
-            try:
-                x_index = int(self.xaxis[-1])
-            except ValueError:
-                x_index = ""
-
-            try:
-                y_index = int(self.yaxis[-1])
-            except ValueError:
-                y_index = ""
-
-            trace["xaxis"] = "x" + x_index
-            trace["yaxis"] = "y" + y_index
-
-            trace_list.append(trace)
-
-        return trace_list, icoord, dcoord, ordered_labels, P["leaves"]