Obsolete utils.OrderedDict: replace with built-in collections.OrderedDict (#367)

* replace internal `OrderedDict` with `collections` version

* handle API removals: use deprecation metadata: display reason to user

Author: alexlancaster

src/PyPop/_deprecations.py

@@ -124,6 +124,14 @@
         "reason": "Lowercased for PEP8 compliance.",
         "changed": "1.4.0",
     },
+    "PyPop.Utils.OrderedDict": {
+        "removed": "1.4.0",
+        "reason": "Obsolete, replaced with :class:`collections.OrderedDict`",
+    },
+    "PyPop.Utils.Index": {
+        "removed": "1.4.0",
+        "reason": "Obsolete, replaced with :class:`collections.OrderedDict` with it's own ``Index`` class",
+    },
     "PyPop.GUIApp": {
         "removed": "1.4.0",
         "reason": "Obsolete, never fully implemented a full ``wxPython`` UI. Replaced by built-in Tkinter file-picker",
@@ -153,10 +161,15 @@ def __init__(self, mapping):
         self.mapping = mapping
 
     def find_spec(self, fullname, _path, _target=None):
-        if fullname in self.mapping:
-            info = self.mapping[fullname]
+        if fullname not in self.mapping:
+            return None
+
+        info = self.mapping[fullname]
+        reason = info.get("reason", "")
+
+        # ---- Case 1: renamed module ----
+        if "new" in info:
             new_name = info["new"]
-            reason = info.get("reason", "")
 
             # Import the replacement module
             module = importlib.import_module(new_name)
@@ -178,4 +191,14 @@ def find_spec(self, fullname, _path, _target=None):
             # Return the spec for the module so import machinery can continue
             return module.__spec__
 
+        # ---- Case 2: removed module ----
+        if "removed" in info:
+            removed_in = info["removed"]
+
+            msg = f"Module '{fullname}' was removed in PyPop {removed_in}."
+            if reason:
+                msg += f" {reason}"
+
+            raise ModuleNotFoundError(msg)
+
         return None

src/PyPop/parsers.py

@@ -46,9 +46,10 @@
 """
 
 import operator
+from collections import OrderedDict
 
 from PyPop import logger
-from PyPop.utils import OrderedDict, StringMatrix, getStreamType
+from PyPop.utils import StringMatrix, getStreamType
 
 
 class ParseFile:
@@ -210,7 +211,7 @@ def _mapFields(self, line, fieldList):
                 # and inserting `HLA-A', or `DQB1_1' and `DQB1_2' should
                 # both be inserted at `DQB1'
 
-                if assoc.has_key(key):
+                if key in assoc:
                     assoc[key] = assoc[key], i
                 else:
                     assoc[key] = i
@@ -465,10 +466,10 @@ def _genDataStructures(self):
         self.totalLocusCount = len(self.alleleMap)
 
         # freeze the list of locusKeys in a particular order
-        self.locusKeys = self.alleleMap.keys()
+        self.locusKeys = list(self.alleleMap.keys())
 
         # freeze list of non-allel data
-        self.extraKeys = self.nonAlleleMap.keys()
+        self.extraKeys = list(self.nonAlleleMap.keys())
 
         # create an empty-list of lists to store all the row data
         # self.individualsList = [[] for line in range(0, self.totalIndivCount)]
@@ -634,7 +635,7 @@ def _genDataStructures(self):
         logger.debug("sampleMap keys: %s", self.sampleMap.keys())
         logger.debug("sampleMap values: %s", self.sampleMap.values())
 
-        self.locusName = self.sampleMap.keys()[0]
+        self.locusName = next(iter(self.sampleMap))
 
         # turn this into a pseudo-genotype data matrix
 

src/PyPop/utils.py

@@ -782,171 +782,6 @@ def __getitem__(self, group):
         return self.li[idx : idx + self.size]
 
 
-class OrderedDict:
-    """A dictionary class with **ordered** pairs.
-
-    .. deprecated:: 1.3.1
-
-       Will be removed in a later release, to be replaced by internal
-       Python version
-
-    """
-
-    __version__ = "1.1"
-
-    def __init__(self, hash=None):
-        """Creates an ordered dict."""
-        if hash is None:
-            hash = []
-        self.__hash = {}
-        self.KEYS = []
-
-        while hash:
-            k, v, hash = hash[0], hash[1], hash[2:]
-            self.__hash[k] = v
-            self.KEYS.append(k)
-
-    def __addval__(self, key, value):
-        """Internal function to add/change key-value pair (at end)."""
-        try:
-            self.KEYS.index(key)
-        except Exception:
-            self.__hash[key] = value
-            self.KEYS.append(key)
-        else:
-            self.__hash[key] = value
-
-    def __setitem__(self, i, hash):
-        """Adds key-value pairs (existing keys not moved)."""
-        if type(i) is type(Index()):
-            del self.__hash[self.KEYS[i.i]]
-            if len(hash) != 1:
-                self.KEYS[i.i], hash = hash[0], hash[1:]
-            self.__hash[self.KEYS[i.i]] = hash[0]
-        else:
-            self.__addval__(i, hash)
-
-    def __getitem__(self, key):
-        """Returns value of given key."""
-        if type(key) is type(Index()):
-            key = self.KEYS[key.i]
-            return [key, self.__hash[key]]
-        return self.__hash[key]
-
-    def __len__(self):
-        """Returns the number of pairs in the dict."""
-        return len(self.KEYS)
-
-    def index(self, key):
-        """Returns position of key in dict."""
-        return self.KEYS.index(key)
-
-    def keys(self):
-        """Returns list of keys in dict."""
-        return self.KEYS
-
-    def values(self):
-        """Returns list of values in dict."""
-        ret = []
-        for key in self.KEYS:
-            ret.append(self.__hash[key])
-        return ret
-
-    def items(self):
-        """Returns list of tuples of keys and values."""
-        ret = []
-        for key in self.KEYS:
-            ret.append((key, self.__hash[key]))
-        return ret
-
-    def insert(self, i, key, value):
-        """Inserts a key-value pair at a given index."""
-        InsertError = "Duplicate key entry"
-        if key in self.__hash:
-            raise InsertError
-        self.KEYS.insert(i, key)
-        self.__hash[key] = value
-
-    def remove(self, i):
-        """Removes a key-value pair from the dict."""
-        del self.__hash[i]
-        self.KEYS.remove(i)
-
-    def __delitem__(self, i):
-        """Removes a key-value pair from the dict."""
-        if type(i) is not type(Index()):
-            i = Index(self.KEYS.index(i))
-        del self.__hash[self.KEYS[i.i]]
-        del self.KEYS[i.i]
-
-    def reverse(self):
-        """Reverses the order of the key-value pairs."""
-        self.KEYS.reverse()
-
-    def sort(self, cmp=0):
-        """Sorts the dict (allows for sort algorithm)."""
-        if cmp:
-            self.KEYS.sort(cmp)
-        else:
-            self.KEYS.sort()
-
-    def clear(self):
-        """Clears all the entries in the dict."""
-        self.__hash = {}
-        self.KEYS = []
-
-    def copy(self):
-        """Makes copy of dict, also of OrderdDict class."""
-        hash = OrderedDict()
-        hash.KEYS = self.KEYS[:]
-        hash.__hash = self.__hash.copy()
-        return hash
-
-    def get(self, key):
-        """Returns the value of a key."""
-        return self.__hash[key]
-
-    def has_key(self, key):
-        """Looks for existence of key in dict."""
-        return key in self.__hash
-
-    def update(self, dict):
-        """Updates entries in a dict based on another."""
-        self.__hash.update(dict)
-
-    def count(self, key):
-        """Finds occurrences of a key in a dict (0/1)."""
-        return key in self.__hash
-
-    def __getslice__(self, i, j):
-        """Returns an OrderedDict of key-value pairs from a dict."""
-        ret = []
-        for x in range(i, j):
-            ret.append(self.KEYS[x])
-            ret.append(self.__hash[self.KEYS[x]])
-        return OrderedDict(ret)
-
-    def __setslice__(self, i, j, hash):
-        """Sets a slice of elements from the dict."""
-        hash = list(hash)
-        for x in range(i, j):
-            k, v, hash = hash[0], hash[1], hash[2:]
-            self.__setitem__(Index(x), [k, v])
-
-
-class Index:
-    """Returns an Index object for :class:`OrderedDict`.
-
-    .. deprecated:: 1.3.1
-
-       Will be removed in a later release, to be replaced by internal
-       Python version
-    """
-
-    def __init__(self, i=0):
-        self.i = i
-
-
 ### global FUNCTIONS start here
 
 

website/helpers.py

@@ -292,7 +292,7 @@ def parse_ver(v):
 
             elif status == "removed":
                 lines.append(f".. versionremoved:: {version}")
-                lines.append(INDENT + "The following modules were removed:")
+                lines.append(INDENT + "The following modules or classes were removed:")
                 lines.append("")
                 for old, new, reason in sorted(items):
                     lines.append(f"{BULLET_PREFIX}:mod:`{old}`")