From: Eli Bendersky Date: Sat, 1 Nov 2014 13:11:59 +0000 (-0700) Subject: Bump minimal Python 2.x version to 2.7 X-Git-Tag: v0.23~2 X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=3ede870115bfb5fbe8168805fdba7e1e12f934e2;p=pyelftools.git Bump minimal Python 2.x version to 2.7 This lets me banish a local version of OrderedDict, which has issues submitted against it (e.g. pull request #53). Python 2.7 has been out for a while now, it's time to move on. I haven't been testing pyelftools on 2.6 for some time anyway. --- diff --git a/CHANGES b/CHANGES index 926dbe0..72e030b 100644 --- a/CHANGES +++ b/CHANGES @@ -1,6 +1,14 @@ Changelog ========= ++ Version 0.23 (??) + + - Minimal Python 2.x version raised to 2.7 + - Basic support for MIPS (contributed by Karl Vogel). + - Support for PT_NOTE segment parsing (contributed by Alex Deymo). + - Support for parsing symbol table in dynamic segment + (contributed by Nam T. Nguyen). + + Version 0.22 (30.03.2014) - pyelftools repository moved to https://github.com/eliben/pyelftools diff --git a/README.rst b/README.rst index d668f3b..4ed20a1 100644 --- a/README.rst +++ b/README.rst @@ -10,7 +10,7 @@ Pre-requisites -------------- As a user of **pyelftools**, one only needs Python to run. It works with -Python versions 2.6, 2.7 and 3.x (x >= 2). For hacking on **pyelftools** the +Python versions 2.7 and 3.x (x >= 2). For hacking on **pyelftools** the requirements are a bit more strict, please see the `hacking guide `_. diff --git a/elftools/common/ordereddict.py b/elftools/common/ordereddict.py deleted file mode 100644 index 18ee045..0000000 --- a/elftools/common/ordereddict.py +++ /dev/null @@ -1,262 +0,0 @@ -#------------------------------------------------------------------------------- -# elftools: port of OrderedDict to work on Python < 2.7 -# -# Taken from http://code.activestate.com/recipes/576693/ , revision 9 -# Code by Raymond Hettinger. License: MIT -#------------------------------------------------------------------------------- -try: - from thread import get_ident as _get_ident -except ImportError: - from dummy_thread import get_ident as _get_ident - -try: - from _abcoll import KeysView, ValuesView, ItemsView -except ImportError: - pass - - -class OrderedDict(dict): - '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/elftools/common/py3compat.py b/elftools/common/py3compat.py index d57567d..4878bf3 100644 --- a/elftools/common/py3compat.py +++ b/elftools/common/py3compat.py @@ -15,9 +15,6 @@ if PY3: StringIO = io.StringIO BytesIO = io.BytesIO - import collections - OrderedDict = collections.OrderedDict - _iterkeys = "keys" _iteritems = "items" _itervalues = "values" @@ -34,8 +31,6 @@ else: import cStringIO StringIO = BytesIO = cStringIO.StringIO - from .ordereddict import OrderedDict - _iterkeys = "iterkeys" _iteritems = "iteritems" _itervalues = "itervalues" diff --git a/elftools/dwarf/die.py b/elftools/dwarf/die.py index 86830fc..1b42066 100644 --- a/elftools/dwarf/die.py +++ b/elftools/dwarf/die.py @@ -6,11 +6,11 @@ # Eli Bendersky (eliben@gmail.com) # This code is in the public domain #------------------------------------------------------------------------------- -from collections import namedtuple +from collections import namedtuple, OrderedDict import os from ..common.exceptions import DWARFError -from ..common.py3compat import OrderedDict, bytes2str, iteritems +from ..common.py3compat import bytes2str, iteritems from ..common.utils import struct_parse, preserve_stream_pos from .enums import DW_FORM_raw2name diff --git a/tox.ini b/tox.ini index 600ca1c..d1f85bf 100644 --- a/tox.ini +++ b/tox.ini @@ -6,7 +6,3 @@ commands = python test/run_all_unittests.py python test/run_examples_test.py python test/run_readelf_tests.py - -[testenv:py26] -deps = - unittest2