skfolio 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

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/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/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/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/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/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/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.dist-info → skfolio-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: skfolio
-Version: 0.2.1
+Version: 0.2.2
 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>
@@ -62,7 +62,7 @@ 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: docs
 Requires-Dist: Sphinx ; extra == 'docs'
 Requires-Dist: sphinx-gallery ; extra == 'docs'

{skfolio-0.2.1.dist-info → skfolio-0.2.2.dist-info}/RECORD

@@ -2,7 +2,7 @@ skfolio/__init__.py,sha256=5pn5LpTz6v2j2sxGkY97cVRrSPsN3Yav9b6Uw08boEI,618
 skfolio/exceptions.py,sha256=-XniKql9QHgfitMgHsE9UXWVPdjWpNGO2dVk2SsdPWE,662
 skfolio/typing.py,sha256=yEZiCZ6UIyfYUqtfj9Kf2KA9mrjUbmxyzpH9uqVboJs,1378
 skfolio/cluster/__init__.py,sha256=4g-PFB_ld9BhiQ1ZPvvAorpFbRwd_p_DkeRlulDv2Hk,251
-skfolio/cluster/_hierarchical.py,sha256=SoISGgdyq4Rgqq1_TCzMbLv69c8a2Q91j_s9-jqaB3E,12817
+skfolio/cluster/_hierarchical.py,sha256=16INBe5HB7ALODO3RNI8ZjOYALtMZa3U_7EP1aEIxp8,12819
 skfolio/datasets/__init__.py,sha256=9Tpf0Uj8wgr-g7xqvqQP4S4TUYDUNmNmK8t6lqBw2Fs,407
 skfolio/datasets/_base.py,sha256=laAj8vE8evEKv6NAAJdypLrsfmlhqOJ27aP_AcpcxVQ,13952
 skfolio/datasets/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -48,15 +48,15 @@ skfolio/optimization/ensemble/_stacking.py,sha256=2PodXf_JahToShSAbwQRXosEer3ESO
 skfolio/optimization/naive/__init__.py,sha256=Dkr55R48urC-jfYN007NTbei16N91Na_EDYLVqzhGgQ,147
 skfolio/optimization/naive/_naive.py,sha256=lXBUK0-JZd_30xUqnwv3IN1-yvKNVrub2A4ZVdfjmnY,5570
 skfolio/population/__init__.py,sha256=rsPPMUv95aTK7vmpPeQwF8NzFuBwk6RDo5g4HNaPzNM,80
-skfolio/population/_population.py,sha256=DNBjR2Ob_Rz3B70mwLIrWd_ElOvHxDWjN3EQs-rGHCk,29148
+skfolio/population/_population.py,sha256=TqyzJbz82asy9OwJmFDJqGqn9eFOC4Xn4ompGicTyJI,29124
 skfolio/portfolio/__init__.py,sha256=YYtcAPmA2zeCxFGTXegg2FXcA7py6CxOX7IMTdYuXl0,586
-skfolio/portfolio/_base.py,sha256=jO6YKXu8oxE-uldl2CayLvbA40yfeCA1vNa_xm-WcWo,38313
-skfolio/portfolio/_multi_period_portfolio.py,sha256=63RwL0oTn-3L5LON6f2e9J58zw9q8S2gQ5c8JfSnN28,22759
-skfolio/portfolio/_portfolio.py,sha256=I2P-ogv78wx6aRytHN7z8BHLkye-E8T5LinVARgsuIQ,31649
+skfolio/portfolio/_base.py,sha256=XbvCdlhwP-mgnbVppoZxv8gr_IgCv8csx71LigqZ0-M,38282
+skfolio/portfolio/_multi_period_portfolio.py,sha256=Zt2khkaeVwZjUKvL0NAk5kLJtfO19hup3YxCGdgk5Mk,22719
+skfolio/portfolio/_portfolio.py,sha256=sSDX2HzK2KgatCgQakEhENOLE-3jSfwI_xgbiVrCGUY,31609
 skfolio/pre_selection/__init__.py,sha256=VtUtDn-U-Mn_xR2k7yfld0Yb0rPhLakEAiBwUyi-4Z8,189
 skfolio/pre_selection/_pre_selection.py,sha256=w84T14nKmzkgzbw5CW_AIlci741lXYxKUwB5pBjhTTI,12163
 skfolio/preprocessing/__init__.py,sha256=15A1bzfPsbfxxXgGP1gstf4R0E_347Wn18z5W5jH-hk,94
-skfolio/preprocessing/_returns.py,sha256=_7UtXugQPWitNrrZ3M2dUOAun8aVr0lI45Ms6KFiS94,3826
+skfolio/preprocessing/_returns.py,sha256=oo1Mm-UCHwq4ECjfmsRxWzzK1EPsuv-EEtnimvv_nXo,4345
 skfolio/prior/__init__.py,sha256=jql8NTiWlykPKJUXTOPdqm531mP8Pul1QAR6hXTXA6c,446
 skfolio/prior/_base.py,sha256=Dx6rX0X6ymDiieFOI-ik3xMNNFhYEtwLSXOdajf5wZY,1927
 skfolio/prior/_black_litterman.py,sha256=sVx8113xeP4B6LA4rICKp0cgw7w3F46aQzIQY_34QwQ,9400
@@ -70,12 +70,10 @@ skfolio/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 skfolio/utils/bootstrap.py,sha256=3zY2kO_GQURKEcQMCasJOSByde9Mt2IAi3KJH0_a4mk,3550
 skfolio/utils/equations.py,sha256=w0HsYjA7cS0mHYsI9MpixHLkof3HN26nc14ZfqFrHlE,11047
 skfolio/utils/sorting.py,sha256=lSjMvH2L-sSj-06B3MlwBrH1rtjCeGEe4hG894W7TE0,3504
-skfolio/utils/stats.py,sha256=IP36nMc5j5Hcqjbg7lvDIsGp1GWRdOh5jU3W6Z8nkYs,13132
+skfolio/utils/stats.py,sha256=KFzYvaa_F-q7bHZxEewrUDdFSnLX0VR3rcVQ5J7t_fw,13140
 skfolio/utils/tools.py,sha256=xa42f7U3Ki8-CJS6g8w7bKCLI_QMJ8D6LxLBjlEM7Ok,15374
-skfolio/utils/fixes/__init__.py,sha256=knHau8PRZP07XDHR59CW8VWxkpTP0gdr6RAHJrO-zaA,95
-skfolio/utils/fixes/_dendrogram.py,sha256=9aIhSnMwpQHJhQx7IpXC3jlw6YJ3H4XQnnx_d4nMllQ,13551
-skfolio-0.2.1.dist-info/LICENSE,sha256=F6Gi-ZJX5BlVzYK8R9NcvAkAsKa7KO29xB1OScbrH6Q,1526
-skfolio-0.2.1.dist-info/METADATA,sha256=OzW5QNHb_EG_jHtP5lPqWas8EAMyl6FPgS3XP6CXulQ,19585
-skfolio-0.2.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-skfolio-0.2.1.dist-info/top_level.txt,sha256=NXEaoS9Ms7t32gxkb867nV0OKlU0KmssL7IJBVo0fJs,8
-skfolio-0.2.1.dist-info/RECORD,,
+skfolio-0.2.2.dist-info/LICENSE,sha256=F6Gi-ZJX5BlVzYK8R9NcvAkAsKa7KO29xB1OScbrH6Q,1526
+skfolio-0.2.2.dist-info/METADATA,sha256=wd7HlJM1U8tEiQMLgSInMLiDhlcZaQAmhjij_HuXdcc,19585
+skfolio-0.2.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+skfolio-0.2.2.dist-info/top_level.txt,sha256=NXEaoS9Ms7t32gxkb867nV0OKlU0KmssL7IJBVo0fJs,8
+skfolio-0.2.2.dist-info/RECORD,,

skfolio/utils/fixes/__init__.py

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

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"]