pep8 fixes

Author: jlwalke2

src/sasctl/utils/pyml2ds/basic/tree.py

@@ -1,6 +1,10 @@
-import abc, six
+import abc
 import sys
 import unicodedata
+from builtins import str
+
+import six
+
 
 @six.add_metaclass(abc.ABCMeta)
 class TreeParser:
@@ -9,114 +13,102 @@ class TreeParser:
     Attributes
     ----------
     d : dict
-        Dictionary for storing node hierarchy. Used not in all models. 
+        Dictionary for storing node hierarchy. Not used in all models.
     out_transform : string
-        Output transformation for generated value. For example, for logreg is used: 1 / (1 + exp(-{0})), where {0} stands for resulting gbvalue.
+        Output transformation for generated value. For example, if logreg is
+        used: 1 / (1 + exp(-{0})), where {0} stands for resulting gbvalue.
     out_var_name : string
         Name used for output variable.
+
     """
     def __init__(self):
         self.d = {}
 
+    def init(self, root, tree_id=0):
+        """Custom init method. Need to be called before using TreeParser.
 
-    """Custom init method. Need to be called before using TreeParser.
+        Attributes
+        ----------
+        root : node
+            Tree root node.
+        tree_id : int
+            Id of current tree.
 
-    Attributes
-    ----------
-    root : node
-        Tree root node.
-    tree_id : int
-        Id of current tree.
-    """
-    def init(self, root, tree_id=0):
+        """
         self._root = root
         self._node = root
         self._tree_id = tree_id
-
         self._depth = -1
         self._indent = 4
 
-
     def _gen_dict(self):
         self.d = {}
 
-    
     def _get_indent(self):
         return " " * self._indent * self._depth
 
-
     @abc.abstractmethod
     def _not_leaf(self):
         pass
 
-
     @abc.abstractmethod
     def _get_var(self):
         pass
 
-
     @abc.abstractmethod
     def _go_left(self):
         pass
 
-
     @abc.abstractmethod
     def _go_right(self):
         pass
 
-
     @abc.abstractmethod
     def _left_node(self):
         pass
 
-
     @abc.abstractmethod
     def _right_node(self):
         pass
 
-
     @abc.abstractmethod
     def _missing_node(self):
         pass
 
-
     @abc.abstractmethod
     def _split_value(self):
         pass
 
-
     @abc.abstractmethod
     def _decision_type(self):
         pass
 
-
     @abc.abstractmethod
     def _leaf_value(self):
         pass
 
-
     def _remove_diacritic(self, input):
         if sys.hexversion >= 0x3000000:
             output = unicodedata.normalize('NFKD', input).encode('ASCII', 'ignore').decode()
         else:
             # On Python < 3.0.0
             if type(input) == str:
-                input = unicode(input, 'ISO-8859-1')
+                input = str(input, 'ISO-8859-1')
             output = unicodedata.normalize('NFKD', input).encode('ASCII', 'ignore')
-        
+
         return output
 
+    def parse_node(self, f, node=None, test=False):
+        """Recursively parse tree node and write generated SAS code to file.
 
-    """Recursively parses tree node and writes generated SAS code to file.
+        Attributes
+        ----------
+        f : file object
+            Open file for writing output SAS code.
+        node: node
+            Tree node to process.
 
-    Attributes
-    ----------
-    f : file object
-        Open file for writing output SAS code.
-    node: node
-        Tree node to process.
-    """
-    def parse_node(self, f, node=None, test=False):
+        """
         if test:
             self.test = True
 
@@ -135,7 +127,7 @@ def parse_node(self, f, node=None, test=False):
         if self._not_leaf():
             var = self._get_var()[:32]
             var = self._remove_diacritic(var)
-            
+
             split_value = self._split_value()
             if self.test:
                 split_value = int(float(split_value))
@@ -146,11 +138,13 @@ def parse_node(self, f, node=None, test=False):
             elif self._go_right():
                 cond = "not missing({}) and ".format(var)
             else:
-                f.write(self._get_indent() + "if (missing({})) then do;\n".format(var))
+                f.write(self._get_indent() + "if (missing(%s)) then do;\n"
+                        % var)
                 self.parse_node(f, node=self._missing_node())
                 f.write(self._get_indent() + "end;\n")
-            
-            f.write(self._get_indent() + "if ({}{} {} {}) then do;\n".format(cond, var, self._decision_type(), split_value))
+
+            f.write(self._get_indent() + "if ({}{} {} {}) then do;\n".format(
+                cond, var, self._decision_type(), split_value))
             self.parse_node(f, node=self._left_node())
             f.write(self._get_indent() + "end;\n")
             f.write(self._get_indent() + "else do;\n")
@@ -161,7 +155,8 @@ def parse_node(self, f, node=None, test=False):
             if self.test:
                 leaf_value = int(float(leaf_value))
 
-            f.write(self._get_indent() + "treeValue{} = {};\n".format(self._tree_id, leaf_value))
-        
+            f.write(self._get_indent() + "treeValue%s = %s;\n"
+                    % (self._tree_id, leaf_value))
+
         self._node = pnode
         self._depth -= 1

src/sasctl/utils/pyml2ds/connectors/ensembles/core.py

@@ -1,47 +1,52 @@
-import abc, six
+import abc
+
+import six
 
 
 @six.add_metaclass(abc.ABCMeta)
 class EnsembleParser:
-    """Abstract class for parsing decision tree ensebmles.
+    """Abstract class for parsing decision tree ensembles.
 
     Attributes
     ----------
     out_transform : string
-        Output transformation for generated value. For example, for logreg is used: 1 / (1 + exp(-{0})), where {0} stands for resulting gbvalue.
+        Output transformation for generated value. For example, if logreg is
+        used: 1 / (1 + exp(-{0})), where {0} stands for resulting gbvalue.
     out_var_name : string
         Name used for output variable.
+
     """
+
     def __init__(self, out_transform="{0}", out_var_name="P_TARGET"):
         self.out_transform = out_transform
         self.out_var_name = out_var_name
 
-
     @abc.abstractmethod
     def _iter_trees(self):
         pass
 
-    
     def _aggregate(self, booster_count):
-        return "treeValue = sum({});\n".format(', '.join(["treeValue%d" % i for i in range(booster_count)]))
+        return "treeValue = sum({});\n".format(', '.join(
+            ["treeValue%d" % i for i in range(booster_count)]))
 
+    def translate(self, f, test=False):
+        """Translate a gradient boosting model and write SAS scoring code to a file.
 
-    """Translates gradient boosting model and writes SAS scoring code to file.
+        Attributes
+        ----------
+        f : file object
+            Open file for writing output SAS code.
 
-    Attributes
-    ----------
-    f : file object
-        Open file for writing output SAS code.
-    """
-    def translate(self, f, test=False):
+        """
         for booster_id, tree in self._iter_trees():
             f.write("/* Parsing tree {}*/\n".format(booster_id))
-            
+
             self._tree_parser.init(tree, booster_id)
             self._tree_parser.parse_node(f, test=test)
 
             f.write("\n")
-        
+
         f.write("/* Getting target probability */\n")
         f.write(self._aggregate(booster_id + 1))
-        f.write("{} = {};\n".format(self.out_var_name, self.out_transform.format("treeValue")))
+        f.write("{} = {};\n".format(self.out_var_name,
+                                    self.out_transform.format("treeValue")))

src/sasctl/utils/pyml2ds/connectors/ensembles/lgb.py

@@ -9,39 +9,30 @@ class LightgbmTreeParser(TreeParser):
     def _not_leaf(self):
         return 'split_feature' in self._node
 
-
     def _get_var(self):
         return self._features[self._node['split_feature']]
 
-
     def _go_left(self):
         return self._node['default_left']
 
-    
     def _go_right(self):
         return (not self._node['default_left'])
 
-
     def _left_node(self):
         return self._node['left_child']
 
-    
     def _right_node(self):
         return self._node['right_child']
 
-
     def _missing_node(self):
         return None
 
-    
     def _split_value(self):
         return self._node['threshold']
 
-
     def _decision_type(self):
         return self._node['decision_type']
 
-
     def _leaf_value(self):
         return self._node['leaf_value']
 
@@ -53,23 +44,25 @@ class LightgbmParser(EnsembleParser):
     ----------
     booster : lightgbm.basic.Booster
         Booster of lightgbm model.
+
     """
     def __init__(self, booster):
         super(LightgbmParser, self).__init__()
 
         self._booster = booster
-        
         self._dump = booster.dump_model()
+
         if self._dump['objective'] != 'binary sigmoid:1':
-            raise Exception("Unfortunately only binary sigmoid objective function is supported right now. Your objective is %s. Please, open an issue at https://gitlab.sas.com/from-russia-with-love/lgb2sas." % self.dump['objective'])
+            raise ValueError("Only binary sigmoid objective function is "
+                             "currently supported. Received '%s'."
+                             % self.dump['objective'])
 
         self._features = self._dump['feature_names']
         self.out_transform = "1 / (1 + exp(-{0}))"
 
         self._tree_parser = LightgbmTreeParser()
         self._tree_parser._features = self._features
 
-
     def _iter_trees(self):
         for tree in self._dump['tree_info']:
             yield tree['tree_index'], tree['tree_structure']