Removed double leading underscore from internal attributes

Author: lucasimi

src/tdamapper/_common.py

@@ -29,12 +29,12 @@ def warn_user(msg):
 
 class EstimatorMixin:
 
-    def __is_sparse(self, X):
+    def _is_sparse(self, X):
         # simple alternative use scipy.sparse.issparse
         return hasattr(X, "toarray")
 
     def _validate_X_y(self, X, y):
-        if self.__is_sparse(X):
+        if self._is_sparse(X):
             raise ValueError("Sparse data not supported.")
 
         X = np.asarray(X)
@@ -80,10 +80,10 @@ class ParamsMixin:
     scikit-learn `get_params` and `set_params`.
     """
 
-    def __is_param_public(self, k):
+    def _is_param_public(self, k):
         return (not k.startswith("_")) and (not k.endswith("_"))
 
-    def __split_param(self, k):
+    def _split_param(self, k):
         k_split = k.split("__")
         outer = k_split[0]
         inner = "__".join(k_split[1:])
@@ -98,7 +98,7 @@ def get_params(self, deep=True):
         """
         params = {}
         for k, v in self.__dict__.items():
-            if self.__is_param_public(k):
+            if self._is_param_public(k):
                 params[k] = v
                 if hasattr(v, "get_params") and deep:
                     for _k, _v in v.get_params().items():
@@ -111,8 +111,8 @@ def set_params(self, **params):
         """
         nested_params = []
         for k, v in params.items():
-            if self.__is_param_public(k):
-                k_outer, k_inner = self.__split_param(k)
+            if self._is_param_public(k):
+                k_outer, k_inner = self._split_param(k)
                 if not k_inner:
                     if hasattr(self, k_outer):
                         setattr(self, k_outer, v)
@@ -131,7 +131,7 @@ def __repr__(self):
             v_default = getattr(obj_noargs, k)
             v_default_repr = repr(v_default)
             v_repr = repr(v)
-            if self.__is_param_public(k) and not v_repr == v_default_repr:
+            if self._is_param_public(k) and not v_repr == v_default_repr:
                 args_repr.append(f"{k}={v_repr}")
         return f"{self.__class__.__name__}({', '.join(args_repr)})"
 

src/tdamapper/_plot_pyvis.py

@@ -19,7 +19,7 @@
 _TICKS_NUM = 10
 
 
-def __fmt(x, max_len=3):
+def _fmt(x, max_len=3):
     fmt = f".{max_len}g"
     return f"{x:{fmt}}"
 
@@ -220,7 +220,7 @@ def _color(node):
         node_id = int(node)
         n_size = _size(node)
         node_color = _color(node)
-        node_stats = __fmt(node_colors[node])
+        node_stats = _fmt(node_colors[node])
         node_label = f"color: {node_stats}\nnode: {node_id}\nsize: {n_size}"
         node_pos = mapper_plot.positions[node]
         net.add_node(

src/tdamapper/core.py

@@ -297,7 +297,7 @@ def fit(self, X):
         :return: The object itself.
         :rtype: self
         """
-        self.__X = X
+        self._X = X
         return self
 
     def search(self, x):
@@ -314,7 +314,7 @@ def search(self, x):
             dataset.
         :rtype: list[int]
         """
-        return list(range(0, len(self.__X)))
+        return list(range(0, len(self._X)))
 
     def apply(self, X):
         """
@@ -385,27 +385,27 @@ def __init__(
 
     def fit(self, X, y=None):
         X, y = self._validate_X_y(X, y)
-        self.__cover = TrivialCover() if self.cover is None else self.cover
-        self.__clustering = (
+        self._cover = TrivialCover() if self.cover is None else self.cover
+        self._clustering = (
             TrivialClustering() if self.clustering is None else self.clustering
         )
-        self.__verbose = self.verbose
-        self.__failsafe = self.failsafe
-        if self.__failsafe:
-            self.__clustering = FailSafeClustering(
-                clustering=self.__clustering,
-                verbose=self.__verbose,
+        self._verbose = self.verbose
+        self._failsafe = self.failsafe
+        if self._failsafe:
+            self._clustering = FailSafeClustering(
+                clustering=self._clustering,
+                verbose=self._verbose,
             )
-        self.__cover = clone(self.__cover)
-        self.__clustering = clone(self.__clustering)
-        self.__n_jobs = self.n_jobs
+        self._cover = clone(self._cover)
+        self._clustering = clone(self._clustering)
+        self._n_jobs = self.n_jobs
         y = X if y is None else y
         self.graph_ = mapper_graph(
             X,
             y,
-            self.__cover,
-            self.__clustering,
-            n_jobs=self.__n_jobs,
+            self._cover,
+            self._clustering,
+            n_jobs=self._n_jobs,
         )
         self._set_n_features_in(X)
         return self
@@ -451,16 +451,16 @@ def __init__(self, clustering=None, verbose=True):
         self.verbose = verbose
 
     def fit(self, X, y=None):
-        self.__clustering = (
+        self._clustering = (
             TrivialClustering() if self.clustering is None else self.clustering
         )
-        self.__verbose = self.verbose
+        self._verbose = self.verbose
         self.labels_ = None
         try:
-            self.__clustering.fit(X, y)
-            self.labels_ = self.__clustering.labels_
+            self._clustering.fit(X, y)
+            self.labels_ = self._clustering.labels_
         except ValueError as err:
-            if self.__verbose:
+            if self._verbose:
                 _logger.warning("Unable to perform clustering on local chart: %s", err)
             self.labels_ = [0 for _ in X]
         return self

src/tdamapper/cover.py

@@ -97,10 +97,10 @@ def fit(self, X):
         :rtype: self
         """
         metric = get_metric(self.metric, **(self.metric_params or {}))
-        self.__radius = self.radius
-        self.__data = list(enumerate(X))
-        self.__vptree = VPTree(
-            self.__data,
+        self._radius = self.radius
+        self._data = list(enumerate(X))
+        self._vptree = VPTree(
+            self._data,
             metric=_Pullback(_snd, metric),
             metric_params=None,
             kind=self.kind,
@@ -121,11 +121,11 @@ def search(self, x):
         :return: The indices of the neighbors contained in the dataset.
         :rtype: list[int]
         """
-        if self.__vptree is None:
+        if self._vptree is None:
             return []
-        neighs = self.__vptree.ball_search(
+        neighs = self._vptree.ball_search(
             (-1, x),
-            self.__radius,
+            self._radius,
             inclusive=False,
         )
         return [x for (x, _) in neighs]
@@ -198,10 +198,10 @@ def fit(self, X):
         :rtype: self
         """
         metric = get_metric(self.metric, **(self.metric_params or {}))
-        self.__neighbors = self.neighbors
-        self.__data = list(enumerate(X))
-        self.__vptree = VPTree(
-            self.__data,
+        self._neighbors = self.neighbors
+        self._data = list(enumerate(X))
+        self._vptree = VPTree(
+            self._data,
             metric=_Pullback(_snd, metric),
             metric_params=None,
             kind=self.kind,
@@ -223,9 +223,9 @@ def search(self, x):
         :return: The indices of the neighbors contained in the dataset.
         :rtype: list[int]
         """
-        if self.__vptree is None:
+        if self._vptree is None:
             return []
-        neighs = self.__vptree.knn_search((-1, x), self.__neighbors)
+        neighs = self._vptree.knn_search((-1, x), self._neighbors)
         return [x for (x, _) in neighs]
 
 

src/tdamapper/plot.py

@@ -382,29 +382,29 @@ def __init__(
         height=512,
         cmap="jet",
     ):
-        self.__graph = graph
-        self.__dim = dim
-        self.__iterations = iterations
-        self.__seed = seed
-        self.__mapper_plot = MapperPlot(
-            graph=self.__graph,
-            dim=self.__dim,
-            iterations=self.__iterations,
-            seed=self.__seed,
+        self._graph = graph
+        self._dim = dim
+        self._iterations = iterations
+        self._seed = seed
+        self._mapper_plot = MapperPlot(
+            graph=self._graph,
+            dim=self._dim,
+            iterations=self._iterations,
+            seed=self._seed,
         )
-        self.__colors = colors
-        self.__agg = agg
-        self.__title = title
-        self.__width = width
-        self.__height = height
-        self.__cmap = cmap
-        self.__fig = self.__mapper_plot.plot_plotly(
-            colors=self.__colors,
-            agg=self.__agg,
-            title=self.__title,
-            width=self.__width,
-            height=self.__height,
-            cmap=self.__cmap,
+        self._colors = colors
+        self._agg = agg
+        self._title = title
+        self._width = width
+        self._height = height
+        self._cmap = cmap
+        self._fig = self._mapper_plot.plot_plotly(
+            colors=self._colors,
+            agg=self._agg,
+            title=self._title,
+            width=self._width,
+            height=self._height,
+            cmap=self._cmap,
         )
 
     def update(
@@ -451,20 +451,20 @@ def update(
         """
         _update_pos = False
         if seed is not None:
-            self.__seed = seed
+            self._seed = seed
             _update_pos = True
         if iterations is not None:
-            self.__iterations = iterations
+            self._iterations = iterations
             _update_pos = True
         if _update_pos:
-            self.__mapper_plot = MapperPlot(
-                graph=self.__graph,
-                dim=self.__dim,
-                iterations=self.__iterations,
-                seed=self.__seed,
+            self._mapper_plot = MapperPlot(
+                graph=self._graph,
+                dim=self._dim,
+                iterations=self._iterations,
+                seed=self._seed,
             )
-        self.__mapper_plot.plot_plotly_update(
-            self.__fig,
+        self._mapper_plot.plot_plotly_update(
+            self._fig,
             colors=colors,
             agg=agg,
             title=title,
@@ -482,7 +482,7 @@ def plot(self):
             context to be shown.
         :rtype: :class:`plotly.graph_objects.Figure`
         """
-        return self.__fig
+        return self._fig
 
 
 class MapperLayoutStatic:
@@ -543,12 +543,12 @@ def __init__(
         height=512,
         cmap="jet",
     ):
-        self.__colors = colors
-        self.__agg = agg
-        self.__title = title
-        self.__width = width
-        self.__height = height
-        self.__cmap = cmap
+        self._colors = colors
+        self._agg = agg
+        self._title = title
+        self._width = width
+        self._height = height
+        self._cmap = cmap
         self.mapper_plot = MapperPlot(
             graph=graph,
             dim=dim,
@@ -566,10 +566,10 @@ def plot(self):
             :class:`matplotlib.axes.Axes`
         """
         return self.mapper_plot.plot_matplotlib(
-            colors=self.__colors,
-            agg=self.__agg,
-            title=self.__title,
-            width=self.__width,
-            height=self.__height,
-            cmap=self.__cmap,
+            colors=self._colors,
+            agg=self._agg,
+            title=self._title,
+            width=self._width,
+            height=self._height,
+            cmap=self._cmap,
         )

src/tdamapper/utils/unionfind.py

@@ -1,30 +1,30 @@
 class UnionFind:
 
     def __init__(self, X):
-        self.__parent = {x: x for x in X}
-        self.__size = {x: 1 for x in X}
+        self._parent = {x: x for x in X}
+        self._size = {x: 1 for x in X}
 
     def find(self, x):
         root = x
-        while root != self.__parent[root]:
-            root = self.__parent[root]
+        while root != self._parent[root]:
+            root = self._parent[root]
         tmp = x
         while tmp != root:
-            parent = self.__parent[tmp]
-            self.__parent[tmp] = root
+            parent = self._parent[tmp]
+            self._parent[tmp] = root
             tmp = parent
         return root
 
     def union(self, x, y):
         x, y = self.find(x), self.find(y)
         if x != y:
-            x_size, y_size = self.__size[x], self.__size[y]
+            x_size, y_size = self._size[x], self._size[y]
             if x_size < y_size:
                 to_keep, to_move = y, x
             else:
                 to_keep, to_move = x, y
-            self.__parent[to_move] = to_keep
-            self.__size[to_keep] = x_size + y_size
+            self._parent[to_move] = to_keep
+            self._size[to_keep] = x_size + y_size
             return to_keep
         else:
             return x