From 4653c1c63a154f0498beca51d4b64ea0955b3c62 Mon Sep 17 00:00:00 2001 From: Alexandre Detiste Date: Sat, 16 Nov 2024 20:41:15 +0100 Subject: [PATCH] remove backport of collections.OrderedDict for Py2.7 support collections.OrderedDict is available since Python3.1 https://docs.python.org/3/library/collections.html#collections.OrderedDict --- patsy/build.py | 2 +- patsy/compat.py | 8 -- patsy/compat_ordereddict.py | 270 ------------------------------------ patsy/constraint.py | 2 +- patsy/design_info.py | 2 +- 5 files changed, 3 insertions(+), 281 deletions(-) delete mode 100644 patsy/compat_ordereddict.py diff --git a/patsy/build.py b/patsy/build.py index b6d6475..7c86a2f 100644 --- a/patsy/build.py +++ b/patsy/build.py @@ -8,6 +8,7 @@ __all__ = ["design_matrix_builders", "build_design_matrices"] import itertools +from collections import OrderedDict import numpy as np from patsy import PatsyError @@ -22,7 +23,6 @@ from patsy.redundancy import pick_contrasts_for_term from patsy.eval import EvalEnvironment from patsy.contrasts import code_contrast_matrix, Treatment -from patsy.compat import OrderedDict from patsy.missing import NAAction if have_pandas: diff --git a/patsy/compat.py b/patsy/compat.py index 5d56d22..fe745fb 100644 --- a/patsy/compat.py +++ b/patsy/compat.py @@ -21,14 +21,6 @@ # add here explaining their provenance, any changes made, and what versions of # Python require them: -# OrderedDict is only available in Python 2.7+. compat_ordereddict.py has -# comments at the top. -import collections - -if optional_dep_ok and hasattr(collections, "OrderedDict"): - from collections import OrderedDict -else: - from patsy.compat_ordereddict import OrderedDict # 'raise from' available in Python 3+ import sys diff --git a/patsy/compat_ordereddict.py b/patsy/compat_ordereddict.py deleted file mode 100644 index 644a662..0000000 --- a/patsy/compat_ordereddict.py +++ /dev/null @@ -1,270 +0,0 @@ -# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy. -# Passes Python2.7's test suite and incorporates all the latest updates. - -# Author: Raymond Hettinger -# License: MIT License -# http://code.activestate.com/recipes/576693/ revision 9, downloaded 2012-03-28 - -try: - from thread import get_ident as _get_ident -except ImportError: - # Hacked by njs -- I don't have dummy_thread and py3 doesn't have thread, - # so the import fails when nosetests3 tries to load this file. - # from dummy_thread import get_ident as _get_ident - def _get_ident(): - return "" - - -try: - from _abcoll import KeysView, ValuesView, ItemsView -except ImportError: - pass - - -class OrderedDict(dict): # pragma: no cover - "Dictionary that remembers insertion order" - - # An inherited dict maps keys to values. - # The inherited dict provides __getitem__, __len__, __contains__, and get. - # The remaining methods are order-aware. - # Big-O running times for all methods are the same as for regular dictionaries. - - # The internal self.__map dictionary maps keys to links in a doubly linked list. - # The circular doubly linked list starts and ends with a sentinel element. - # The sentinel element never gets deleted (this simplifies the algorithm). - # Each link is stored as a list of length three: [PREV, NEXT, KEY]. - - def __init__(self, *args, **kwds): - """Initialize an ordered dictionary. Signature is the same as for - regular dictionaries, but keyword arguments are not recommended - because their insertion order is arbitrary. - - """ - if len(args) > 1: - raise TypeError("expected at most 1 arguments, got %d" % len(args)) - try: - self.__root - except AttributeError: - self.__root = root = [] # sentinel node - root[:] = [root, root, None] - self.__map = {} - self.__update(*args, **kwds) - - def __setitem__(self, key, value, dict_setitem=dict.__setitem__): - "od.__setitem__(i, y) <==> od[i]=y" - # Setting a new item creates a new link which goes at the end of the linked - # list, and the inherited dictionary is updated with the new key/value pair. - if key not in self: - root = self.__root - last = root[0] - last[1] = root[0] = self.__map[key] = [last, root, key] - dict_setitem(self, key, value) - - def __delitem__(self, key, dict_delitem=dict.__delitem__): - "od.__delitem__(y) <==> del od[y]" - # Deleting an existing item uses self.__map to find the link which is - # then removed by updating the links in the predecessor and successor nodes. - dict_delitem(self, key) - link_prev, link_next, key = self.__map.pop(key) - link_prev[1] = link_next - link_next[0] = link_prev - - def __iter__(self): - "od.__iter__() <==> iter(od)" - root = self.__root - curr = root[1] - while curr is not root: - yield curr[2] - curr = curr[1] - - def __reversed__(self): - "od.__reversed__() <==> reversed(od)" - root = self.__root - curr = root[0] - while curr is not root: - yield curr[2] - curr = curr[0] - - def clear(self): - "od.clear() -> None. Remove all items from od." - try: - for node in self.__map.itervalues(): - del node[:] - root = self.__root - root[:] = [root, root, None] - self.__map.clear() - except AttributeError: - pass - dict.clear(self) - - def popitem(self, last=True): - """od.popitem() -> (k, v), return and remove a (key, value) pair. - Pairs are returned in LIFO order if last is true or FIFO order if false. - - """ - if not self: - raise KeyError("dictionary is empty") - root = self.__root - if last: - link = root[0] - link_prev = link[0] - link_prev[1] = root - root[0] = link_prev - else: - link = root[1] - link_next = link[1] - root[1] = link_next - link_next[0] = root - key = link[2] - del self.__map[key] - value = dict.pop(self, key) - return key, value - - # -- the following methods do not depend on the internal structure -- - - def keys(self): - "od.keys() -> list of keys in od" - return list(self) - - def values(self): - "od.values() -> list of values in od" - return [self[key] for key in self] - - def items(self): - "od.items() -> list of (key, value) pairs in od" - return [(key, self[key]) for key in self] - - def iterkeys(self): - "od.iterkeys() -> an iterator over the keys in od" - return iter(self) - - def itervalues(self): - "od.itervalues -> an iterator over the values in od" - for k in self: - yield self[k] - - def iteritems(self): - "od.iteritems -> an iterator over the (key, value) items in od" - for k in self: - yield (k, self[k]) - - def update(*args, **kwds): - """od.update(E, **F) -> None. Update od from dict/iterable E and F. - - If E is a dict instance, does: for k in E: od[k] = E[k] - If E has a .keys() method, does: for k in E.keys(): od[k] = E[k] - Or if E is an iterable of items, does: for k, v in E: od[k] = v - In either case, this is followed by: for k, v in F.items(): od[k] = v - - """ - if len(args) > 2: - raise TypeError( - "update() takes at most 2 positional " - "arguments (%d given)" % (len(args),) - ) - elif not args: - raise TypeError("update() takes at least 1 argument (0 given)") - self = args[0] - # Make progressively weaker assumptions about "other" - other = () - if len(args) == 2: - other = args[1] - if isinstance(other, dict): - for key in other: - self[key] = other[key] - elif hasattr(other, "keys"): - for key in other.keys(): - self[key] = other[key] - else: - for key, value in other: - self[key] = value - for key, value in kwds.items(): - self[key] = value - - __update = update # let subclasses override update without breaking __init__ - - __marker = object() - - def pop(self, key, default=__marker): - """od.pop(k[,d]) -> v, remove specified key and return the corresponding value. - If key is not found, d is returned if given, otherwise KeyError is raised. - - """ - if key in self: - result = self[key] - del self[key] - return result - if default is self.__marker: - raise KeyError(key) - return default - - def setdefault(self, key, default=None): - "od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od" - if key in self: - return self[key] - self[key] = default - return default - - def __repr__(self, _repr_running={}): - "od.__repr__() <==> repr(od)" - call_key = id(self), _get_ident() - if call_key in _repr_running: - return "..." - _repr_running[call_key] = 1 - try: - if not self: - return "%s()" % (self.__class__.__name__,) - return "%s(%r)" % (self.__class__.__name__, self.items()) - finally: - del _repr_running[call_key] - - def __reduce__(self): - "Return state information for pickling" - items = [[k, self[k]] for k in self] - inst_dict = vars(self).copy() - for k in vars(OrderedDict()): - inst_dict.pop(k, None) - if inst_dict: - return (self.__class__, (items,), inst_dict) - return self.__class__, (items,) - - def copy(self): - "od.copy() -> a shallow copy of od" - return self.__class__(self) - - @classmethod - def fromkeys(cls, iterable, value=None): - """OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S - and values equal to v (which defaults to None). - - """ - d = cls() - for key in iterable: - d[key] = value - return d - - def __eq__(self, other): - """od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive - while comparison to a regular mapping is order-insensitive. - - """ - if isinstance(other, OrderedDict): - return len(self) == len(other) and self.items() == other.items() - return dict.__eq__(self, other) - - def __ne__(self, other): - return not self == other - - # -- the following methods are only used in Python 2.7 -- - - def viewkeys(self): - "od.viewkeys() -> a set-like object providing a view on od's keys" - return KeysView(self) - - def viewvalues(self): - "od.viewvalues() -> an object providing a view on od's values" - return ValuesView(self) - - def viewitems(self): - "od.viewitems() -> a set-like object providing a view on od's items" - return ItemsView(self) diff --git a/patsy/constraint.py b/patsy/constraint.py index 6147a70..4f81154 100644 --- a/patsy/constraint.py +++ b/patsy/constraint.py @@ -455,7 +455,7 @@ def _check_lincon(input, varnames, coefs, constants): def test_linear_constraint(): import pytest - from patsy.compat import OrderedDict + from collections import OrderedDict t = _check_lincon diff --git a/patsy/design_info.py b/patsy/design_info.py index 12a9510..1bc9f63 100644 --- a/patsy/design_info.py +++ b/patsy/design_info.py @@ -21,12 +21,12 @@ __all__ = ["DesignInfo", "FactorInfo", "SubtermInfo", "DesignMatrix"] import warnings +from collections import OrderedDict import numpy as np from patsy import PatsyError from patsy.util import atleast_2d_column_default -from patsy.compat import OrderedDict from patsy.util import ( repr_pretty_delegate, repr_pretty_impl,