Merge PR #55 DSSExtensibleDict → DSSInternalDict

from fix/dss70-internal-dict

Author: instanceofme

dataikuapi/dss/ml.py

@@ -1,7 +1,7 @@
 from ..utils import DataikuException
 from ..utils import DataikuUTF8CSVReader
 from ..utils import DataikuStreamedHttpUTF8CSVReader
-from ..utils import DSSExtensibleDict
+from ..utils import DSSInternalDict
 import json
 import time
 from .metrics import ComputedMetrics
@@ -723,7 +723,7 @@ def get_partial_dependencies(self):
         return DSSPartialDependencies(data)
 
 
-class DSSSubpopulationGlobal(DSSExtensibleDict):
+class DSSSubpopulationGlobal(DSSInternalDict):
     """
     Object to read details of performance on global population used for subpopulation analyses.
 
@@ -761,7 +761,7 @@ def get_prediction_info(self):
             }
 
 
-class DSSSubpopulationModality(DSSExtensibleDict):
+class DSSSubpopulationModality(DSSInternalDict):
     """
     Object to read details of a subpopulation analysis modality
 
@@ -777,12 +777,6 @@ def __init__(self, feature_name, computed_as_type, data, prediction_type):
         elif computed_as_type == "NUMERIC":
             self.definition = DSSSubpopulationNumericModalityDefinition(feature_name, data)
 
-    def get_raw(self):
-        """
-        Gets the raw dictionary of the subpopulation analysis modality
-        """
-        return self.internal_dict
-    
     def get_definition(self):
         """
         Gets the definition of the subpopulation analysis modality
@@ -890,7 +884,7 @@ def __repr__(self):
             return "DSSSubpopulationCategoryModalityDefinition(%s='%s')" % (self.feature_name, self.value)
 
 
-class DSSSubpopulationAnalysis(DSSExtensibleDict):
+class DSSSubpopulationAnalysis(DSSInternalDict):
     """
     Object to read details of a subpopulation analysis of a trained model
 
@@ -942,22 +936,16 @@ def get_modality_data(self, definition=None):
         if isinstance(definition, DSSSubpopulationModalityDefinition):
             modality_candidates = [m for m in self.modalities if m.definition.index == definition.index]
             if len(modality_candidates) == 0:
-                raise ValueError("Modality with index '%s' not found" % modality["index"])
+                raise ValueError("Modality with index '%s' not found" % definition.index)
             return modality_candidates[0]
 
         for m in self.modalities:
             if m.definition.contains(definition):
                 return m
         raise ValueError("Modality not found: %s" % definition)
 
-    def get_raw(self):
-        """
-        Gets the raw dictionary of the subpopulation analysis
-        """
-        return self.internal_dict
-
 
-class DSSSubpopulationAnalyses(DSSExtensibleDict):
+class DSSSubpopulationAnalyses(DSSInternalDict):
     """
     Object to read details of subpopulation analyses of a trained model
 
@@ -971,12 +959,6 @@ def __init__(self, data, prediction_type):
         for analysis in data.get("subpopulationAnalyses", []):
             self.analyses.append(DSSSubpopulationAnalysis(analysis, prediction_type))
 
-    def get_raw(self):
-        """
-        Gets the raw dictionary of subpopulation analyses
-        """
-        return self.internal_dict
-    
     def get_global(self):
         """
         Retrieves information and performance on the full dataset used to compute the subpopulation analyses
@@ -987,19 +969,19 @@ def list_analyses(self):
         """
         Lists all features on which subpopulation analyses have been computed
         """
-        return [analysis["feature"] for analysis in self.analyses]
+        return [analysis.get("feature") for analysis in self.analyses]
 
     def get_analysis(self, feature):
         """
         Retrieves the subpopulation analysis for a particular feature
         """
         try:
-            return next(analysis for analysis in self.analyses if analysis["feature"] == feature)
+            return next(analysis for analysis in self.analyses if analysis.get("feature") == feature)
         except StopIteration:
             raise ValueError("Subpopulation analysis for feature '%s' cannot be found" % feature)
 
 
-class DSSPartialDependence(DSSExtensibleDict):
+class DSSPartialDependence(DSSInternalDict):
     """
     Object to read details of partial dependence of a trained model
 
@@ -1019,14 +1001,8 @@ def get_computation_params(self):
             "onSample":  self.get("onSample")
         }
 
-    def get_raw(self):
-        """
-        Gets the raw dictionary of the partial dependence
-        """
-        return self.internal_dict
-
 
-class DSSPartialDependencies(DSSExtensibleDict):
+class DSSPartialDependencies(DSSInternalDict):
     """
     Object to read details of partial dependencies of a trained model
 
@@ -1039,24 +1015,18 @@ def __init__(self, data):
         for pd in data.get("partialDependencies", []):
             self.partial_dependencies.append(DSSPartialDependence(pd))
 
-    def get_raw(self):
-        """
-        Gets the raw dictionary of partial dependencies
-        """
-        return self.internal_dict
-
     def list_features(self):
         """
         Lists all features on which partial dependencies have been computed
         """
-        return [partial_dep["feature"] for partial_dep in self.partial_dependencies]
+        return [partial_dep.get("feature") for partial_dep in self.partial_dependencies]
 
     def get_partial_dependence(self, feature):
         """
         Retrieves the partial dependencies for a particular feature
         """
         try:
-            return next(pd for pd in self.partial_dependencies if pd["feature"] == feature)
+            return next(pd for pd in self.partial_dependencies if pd.get("feature") == feature)
         except StopIteration:
             raise ValueError("Partial dependence for feature '%s' cannot be found" % feature)
 

dataikuapi/utils.py

@@ -95,73 +95,27 @@ def str_to_bool(s):
                 yield [none_if_throws(caster)(val)
                         for (caster, val) in dku_zip_longest(casters, uncasted_tuple)]
 
-class DSSExtensibleDict(dict):
+class DSSInternalDict(object):
     """
-    Utility to define dict-like objects that can be sub-classed.
-    
-    Behaves like dict for most common operations. In particular, 
-    it is possible to update an instance of `:class:`dataikuapi.dss.ml.DSSExtensibleDict` 
-    with either a dict or another instance of `:class:`dataikuapi.dss.ml.DSSExtensibleDict`.
-    
-    Provides an `internal_dict` dict field that is the actual holder of the data.
+    Class that provides some helpers and an `_internal_dict` dict field that is the actual holder of the data.
     """
 
     def __init__(self, orig_dict=None):
         if orig_dict is None:
-            self.internal_dict = dict()
+            self._internal_dict = dict()
         else:
-            self.internal_dict = orig_dict
+            self._internal_dict = orig_dict
 
-    def __getitem__(self, key):
-        return self.internal_dict[key]
+    def get(self, name, default=None):
+        return self._internal_dict.get(name, default)
 
-    def __iter__(self):
-        return self.internal_dict.__iter__()
+    def get_raw(self):
+        """
+        Gets the raw dictionary of the actual data
 
-    def __setitem__(self, key, value):
-        self.internal_dict[key] = value
+        :rtype: dict
+        """
+        return self._internal_dict
 
     def __repr__(self):
-        return self.__class__.__name__ + "(" + self.internal_dict.__repr__() + ")"
-    
-    def __len__(self):
-        return self.internal_dict.__len__()
-
-    def clear(self):
-        self.internal_dict.clear()
-    
-    def __contains__(self, key):
-        return self.internal_dict.__contains__(key)
-
-    def copy(self):
-        return self.internal_dict.copy()
-
-    def fromkeys(self, sequence, value=None):
-        return self.internal_dict.fromkeys(sequence, value)
-
-    def get(self, key, value=None):
-        return self.internal_dict.get(key, value)
-
-    def items(self):
-        return self.internal_dict.items()
-
-    def keys(self):
-        return self.internal_dict.keys()
-
-    def popitem(self):
-        return self.internal_dict.popitem()
-
-    def pop(self, key, *argv):
-        return self.internal_dict.pop(key, *argv)
-
-    def setdefault(self, key, default_value=None):
-        return self.internal_dict.setdefault(key, default_value)
-
-    def update(self, *args, **kwargs):
-        if len(args) == 1 and isinstance(args[0], DSSExtensibleDict):
-            self.internal_dict.update(args[0].internal_dict, **kwargs)
-        else:
-            self.internal_dict.update(*args, **kwargs)
-
-    def values(self):
-        return self.internal_dict.values()
+        return self.__class__.__name__ + "(" + self._internal_dict.__repr__() + ")"