refactor thanks to CodeClimate

satella/coding/predicates.py

@@ -254,29 +254,31 @@ def build_structure(struct: tp.Union[tuple, list, dict],
     """
     if not nested_call:
         v = build_structure(struct, argument, None, True)
-        return final_operator(v)
-
-    from satella.coding.structures import HashableWrapper
-    if isinstance(struct, tp.MutableMapping):
-        new_dict = {}
-        for key, value in struct.items():
-            key = build_structure(key, argument, None, True)
-            value = build_structure(value, argument, None, True)
-            new_dict[key] = value
-            return new_dict
-    elif isinstance(struct, tp.Sequence):
-        new_seq = []
-        for elem in struct:
-            if isinstance(elem, PredicateClass):
-                elem = elem(argument)
-            else:
-                elem = build_structure(elem, argument, None, True)
-            new_seq.append(elem)
-        return struct.__class__(new_seq)
-    elif isinstance(struct, HashableWrapper):
-        obj = getattr(struct, '_Proxy__obj')
-        return build_structure(obj, argument, None, True)
-    elif isinstance(struct, PredicateClass):
-        return struct(argument)
+        f = final_operator(v)
     else:
-        return struct
+        from satella.coding.structures import HashableWrapper
+        if isinstance(struct, tp.MutableMapping):
+            new_dict = {}
+            for key, value in struct.items():
+                key = build_structure(key, argument, None, True)
+                value = build_structure(value, argument, None, True)
+                new_dict[key] = value
+                f = new_dict
+                break
+        elif isinstance(struct, tp.Sequence):
+            new_seq = []
+            for elem in struct:
+                if isinstance(elem, PredicateClass):
+                    elem = elem(argument)
+                else:
+                    elem = build_structure(elem, argument, None, True)
+                new_seq.append(elem)
+            f = struct.__class__(new_seq)
+        elif isinstance(struct, HashableWrapper):
+            obj = getattr(struct, '_Proxy__obj')
+            f = build_structure(obj, argument, None, True)
+        elif isinstance(struct, PredicateClass):
+            f = struct(argument)
+        else:
+            f = struct
+    return f

satella/coding/structures/sparse_matrix.py

@@ -188,14 +188,15 @@ class SparseMatrix(tp.Generic[T]):
         :param row_no: row number, numbered from 0
         """
         if row_no not in self.rows_dict:  # check so as to avoid adding new entries
-            return [None] * self.no_cols
-        cols = self.rows_dict[row_no]
-        output = []
-        for i in range(self.no_cols):
-            if i in cols:
-                output.append(cols[i])
-            else:
-                output.append(None)
+            output = [None] * self.no_cols
+        else:
+            cols = self.rows_dict[row_no]
+            output = []
+            for i in range(self.no_cols):
+                if i in cols:
+                    output.append(cols[i])
+                else:
+                    output.append(None)
         return output
 
     def shoot(self) -> 'SparseMatrix':
@@ -283,21 +284,24 @@ class SparseMatrix(tp.Generic[T]):
         col, row = self._sanitize_key(item)
 
         if col is Ellipsis and row is Ellipsis:
-            return list(self)
+            v = list(self)
         elif col is Ellipsis:
-            return [self[col_no, row] for col_no in range(self.no_cols)]
+            v = [self[col_no, row] for col_no in range(self.no_cols)]
         elif row is Ellipsis:
-            return [self[col, row_no] for row_no in range(self.no_rows)]
+            v = [self[col, row_no] for row_no in range(self.no_rows)]
         else:
             if row >= self.no_rows:
                 raise IndexError()
             elif col >= self.no_cols:
                 raise IndexError()
+
             if row not in self.rows_dict:  # check so as to avoid adding new entries
-                return None
-            if col not in self.rows_dict[row]:
-                return None
-            return self.rows_dict[row][col]
+                v = None
+            elif col not in self.rows_dict[row]:
+                v = None
+            else:
+                v = self.rows_dict[row][col]
+        return v
 
     @silence_excs(TypeError, returns=0)
     def _calculate_column_count(self) -> int:
@@ -321,10 +325,7 @@ class SparseMatrix(tp.Generic[T]):
                 del self[col, row_no]
         else:
             # Check if the element is there
-            if row not in self.rows_dict:
-                return
-
-            if col not in self.rows_dict[row]:
+            if (row not in self.rows_dict) or (col not in self.rows_dict[row]):
                 return
 
             del self.rows_dict[row][col]

satella/coding/structures/syncable_droppable.py

@@ -194,6 +194,7 @@ class SyncableDroppable(RMonitor, tp.Generic[K, V]):
                     # We no longer have ANY data
                     self.start_entry = self.stop_entry = None
                 return True
+
         finally:
             try_close(iterator)
         return False

satella/coding/transforms/jsonify.py

@@ -19,22 +19,23 @@ def jsonify(data: tp.Any) -> tp.Optional[tp.Union[str, int, float, list, dict]]:
     :return: JSON-able data
     """
     if data is None:
-        return None
+        v = None
     elif isinstance(data, (int, float, str)):
-        return data
+        v = data
     elif isinstance(data, enum.Enum):
-        return data.value
+        v = data.value
     elif isinstance(data, JSONAble):
-        return jsonify(data.to_json())
+        v = jsonify(data.to_json())
     elif isinstance(data, tp.Mapping):
         new_mapping = {}
         for key in data:
             new_mapping[jsonify(key)] = jsonify(data[key])
-        return new_mapping
+        v = new_mapping
     elif isinstance(data, (tp.Iterable, tp.Iterator)):
-        return [jsonify(elem) for elem in data]
+        v = [jsonify(elem) for elem in data]
     else:
         try:
-            return str(data)
+            v = str(data)
         except TypeError:
-            return repr(data)
+            v = repr(data)
+    return v

satella/json.py

@@ -30,30 +30,31 @@ class JSONEncoder(json.JSONEncoder):
 
     def default(self, o: tp.Any) -> Jsonable:
         if hasattr(o, 'to_json'):
-            return o.to_json()
+            v = o.to_json()
         elif isinstance(o, (int, float, str, NoneType)):
-            return o
+            v = o
         elif isinstance(o, enum.Enum):
-            return o.value
+            v = o.value
         elif isinstance(o, (list, tuple)):
-            return [self.default(v) for v in o]
+            v = [self.default(v) for v in o]
         elif isinstance(o, dict):
-            return {self.default(k): self.default(v) for k, v in o.items()}
-
-        try:
-            return super().default(o)
-        except TypeError:
-            dct = {}
+            v = {self.default(k): self.default(v) for k, v in o.items()}
+        else:
             try:
-                for k, v in o.__dict__.items():
-                    dct[k] = self.default(v)
-            except AttributeError:  # o has no attribute '__dict__', try with slots
+                v = super().default(o)
+            except TypeError:
+                dct = {}
                 try:
-                    for slot in o.__slots__:
-                        dct[slot] = self.default(getattr(o, slot))
-                except AttributeError:  # it doesn't have __slots__ either?
-                    return '<an instance of %s>' % (o.__class__.__name__,)
-            return dct
+                    for k, v in o.__dict__.items():
+                        dct[k] = self.default(v)
+                except AttributeError:  # o has no attribute '__dict__', try with slots
+                    try:
+                        for slot in o.__slots__:
+                            dct[slot] = self.default(getattr(o, slot))
+                    except AttributeError:  # it doesn't have __slots__ either?
+                        v = '<an instance of %s>' % (o.__class__.__name__,)
+                v = dct
+        return v
 
 
 def json_encode(x: tp.Any) -> str:
@@ -109,10 +110,11 @@ def read_json_from_file(path: str) -> JSONAble:
     try:
         import ujson
         with open(path, 'r') as f_in:
-            return ujson.load(f_in)
+            v = ujson.load(f_in)
     except ImportError:
         with open(path, 'r') as f_in:
             try:
-                return json.load(f_in)
+                v = json.load(f_in)
             except json.decoder.JSONDecodeError as e:
                 raise ValueError(str(e))
+    return v