Improved handling of nested params. Added repr method

Author: lucasimi

src/tdamapper/_common.py

@@ -81,8 +81,14 @@ class ParamsMixin:
     scikit-learn `get_params` and `set_params`.
     """
 
-    def __is_param_internal(self, k):
-        return k.startswith('_') or k.endswith('_')
+    def __is_param_public(self, k):
+        return (not k.startswith('_')) and (not k.endswith('_'))
+
+    def __split_param(self, k):
+        k_split = k.split('__')
+        outer = k_split[0]
+        inner = '__'.join(k_split[1:])
+        return outer, inner
 
     def get_params(self, deep=True):
         """
@@ -91,18 +97,44 @@ def get_params(self, deep=True):
         :param deep: A flag for returning also nested parameters.
         :type deep: bool, optional.
         """
-        params = self.__dict__.items()
-        return {k: v for k, v in params if not self.__is_param_internal(k)}
+        params = {}
+        for k, v in self.__dict__.items():
+            if self.__is_param_public(k):
+                params[k] = v
+                if hasattr(v, 'get_params') and deep:
+                    for _k, _v in v.get_params().items():
+                        params[f'{k}__{_k}'] = _v
+        return params
 
     def set_params(self, **params):
         """
         Set public parameters. Only updates attributes that already exist.
         """
+        nested_params = []
         for k, v in params.items():
-            if hasattr(self, k) and not self.__is_param_internal(k):
-                setattr(self, k, v)
+            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)
+                else:
+                    nested_params.append((k_outer, k_inner, v))
+        for k_outer, k_inner, v in nested_params:
+            if hasattr(self, k_outer):
+                k_attr = getattr(self, k_outer)
+                k_attr.set_params(**{k_inner: v})
         return self
 
+    def __repr__(self):
+        obj = type(self)()
+        rep = f'{self.__class__.__name__}('
+        for k, v in self.__dict__.items():
+            obj_v = getattr(obj, k)
+            if self.__is_param_public(k) and not v == obj_v:
+                rep += f'{k}={v}, '
+        rep += ')'
+        return rep
+
 
 def clone(estimator):
     """

tests/test_unit_params.py

@@ -0,0 +1,50 @@
+import unittest
+
+from tdamapper.core import MapperAlgorithm
+from tdamapper.cover import (
+    BallCover,
+    KNNCover,
+    CubicalCover
+)
+from tdamapper.clustering import MapperClustering
+
+
+class TestParams(unittest.TestCase):
+
+    def test_params_mapper(self):
+        est = MapperAlgorithm(
+            cover=CubicalCover(
+                n_intervals=3,
+                overlap_frac=0.3,
+            ),
+        )
+        params = est.get_params(deep=False)
+        self.assertEquals(5, len(params))
+        params = est.get_params()
+        self.assertEquals(12, len(params))
+        self.assertEquals(3, params['cover__n_intervals'])
+        self.assertEquals(0.3, params['cover__overlap_frac'])
+        est.set_params(cover__n_intervals=2, cover__overlap_frac=0.2)
+        params = est.get_params()
+        self.assertEquals(12, len(params))
+        self.assertEquals(2, params['cover__n_intervals'])
+        self.assertEquals(0.2, params['cover__overlap_frac'])
+
+    def test_params_clust(self):
+        est = MapperClustering(
+            cover=CubicalCover(
+                n_intervals=3,
+                overlap_frac=0.3,
+            ),
+        )
+        params = est.get_params(deep=False)
+        self.assertEquals(3, len(params))
+        params = est.get_params()
+        self.assertEquals(10, len(params))
+        self.assertEquals(3, params['cover__n_intervals'])
+        self.assertEquals(0.3, params['cover__overlap_frac'])
+        est.set_params(cover__n_intervals=2, cover__overlap_frac=0.2)
+        params = est.get_params()
+        self.assertEquals(10, len(params))
+        self.assertEquals(2, params['cover__n_intervals'])
+        self.assertEquals(0.2, params['cover__overlap_frac'])