PEP-8 long lines and dunders (#245)

This patch massively reformats the whole codebase mainly wrapping
long lines and eliminating dundered private attributes.

1 files changed, 50 insertions, 36 deletions

diff --git a/pysnmp/smi/indices.py b/pysnmp/smi/indices.py
index 677ac97c..f55f7e6a 100644
--- a/pysnmp/smi/indices.py
+++ b/pysnmp/smi/indices.py
@@ -11,45 +11,50 @@ class OrderedDict(dict):
     """Ordered dictionary used for indices"""
 
     def __init__(self, *args, **kwargs):
-        self.__keys = []
-        self.__dirty = True
         super(OrderedDict, self).__init__()
+
+        self._keys = []
+        self._dirty = True
+        self._keysLens = []
+
         if args:
             self.update(*args)
+
         if kwargs:
             self.update(**kwargs)
 
     def __setitem__(self, key, value):
         super(OrderedDict, self).__setitem__(key, value)
-        if key not in self.__keys:
-            self.__keys.append(key)
-            self.__dirty = True
+        if key not in self._keys:
+            self._keys.append(key)
+            self._dirty = True
 
     def __delitem__(self, key):
         super(OrderedDict, self).__delitem__(key)
-        if key in self.__keys:
-            self.__keys.remove(key)
-            self.__dirty = True
+        if key in self._keys:
+            self._keys.remove(key)
+            self._dirty = True
 
     def clear(self):
         super(OrderedDict, self).clear()
-        self.__keys = []
-        self.__dirty = True
+        self._keys = []
+        self._dirty = True
 
     def keys(self):
-        if self.__dirty:
-            self.__order()
-        return list(self.__keys)
+        if self._dirty:
+            self._order()
+        return list(self._keys)
 
     def values(self):
-        if self.__dirty:
-            self.__order()
-        return [self[k] for k in self.__keys]
+        if self._dirty:
+            self._order()
+        return [self[k] for k in self._keys]
 
     def items(self):
-        if self.__dirty:
-            self.__order()
-        return [(k, self[k]) for k in self.__keys]
+        if self._dirty:
+            self._order()
+
+        return [(k, self[k]) for k in self._keys]
 
     def update(self, *args, **kwargs):
         if args:
@@ -57,6 +62,7 @@ class OrderedDict(dict):
             if hasattr(iterable, 'keys'):
                 for k in iterable:
                     self[k] = iterable[k]
+
             else:
                 for k, v in iterable:
                     self[k] = v
@@ -68,16 +74,19 @@ class OrderedDict(dict):
     def sortingFun(self, keys):
         keys.sort()
 
-    def __order(self):
-        self.sortingFun(self.__keys)
-        self.__keysLens = sorted(set(len(k) for k in self.__keys), reverse=True)
-        self.__dirty = False
+    def _order(self):
+        self.sortingFun(self._keys)
+
+        self._keysLens = sorted(
+            set(len(k) for k in self._keys), reverse=True)
+
+        self._dirty = False
 
     def nextKey(self, key):
-        if self.__dirty:
-            self.__order()
+        if self._dirty:
+            self._order()
 
-        keys = self.__keys
+        keys = self._keys
 
         if key in keys:
             nextIdx = keys.index(key) + 1
@@ -92,30 +101,35 @@ class OrderedDict(dict):
             raise KeyError(key)
 
     def getKeysLens(self):
-        if self.__dirty:
-            self.__order()
-        return self.__keysLens
+        if self._dirty:
+            self._order()
+
+        return self._keysLens
 
 
 class OidOrderedDict(OrderedDict):
     """OID-ordered dictionary used for indices"""
 
     def __init__(self, *args, **kwargs):
-        self.__keysCache = {}
         OrderedDict.__init__(self, *args, **kwargs)
 
+        self._keysCache = {}
+
     def __setitem__(self, key, value):
         OrderedDict.__setitem__(self, key, value)
-        if key not in self.__keysCache:
+
+        if key not in self._keysCache:
             if isinstance(key, tuple):
-                self.__keysCache[key] = key
+                self._keysCache[key] = key
+
             else:
-                self.__keysCache[key] = [int(x) for x in key.split('.') if x]
+                self._keysCache[key] = [int(x) for x in key.split('.') if x]
 
     def __delitem__(self, key):
         OrderedDict.__delitem__(self, key)
-        if key in self.__keysCache:
-            del self.__keysCache[key]
+
+        if key in self._keysCache:
+            del self._keysCache[key]
 
     def sortingFun(self, keys):
-        keys.sort(key=lambda k, d=self.__keysCache: d[k])
+        keys.sort(key=lambda k, d=self._keysCache: d[k])