From f02169ea715763fd8df6386e15f5e5f402bab751 Mon Sep 17 00:00:00 2001 From: Jakub Roztocil Date: Thu, 24 Apr 2014 19:56:11 +0200 Subject: [PATCH] Added Python 2.6 compatible OrderedDict To preserver ordr of headers, parameters, etc. --- httpie/compat.py | 134 +++++++++++++++++++++++++++++++++++++++++++ httpie/input.py | 7 +-- tests/test_httpie.py | 3 +- tests/test_output.py | 3 +- 4 files changed, 139 insertions(+), 8 deletions(-) diff --git a/httpie/compat.py b/httpie/compat.py index f378e43a..bba26a8d 100644 --- a/httpie/compat.py +++ b/httpie/compat.py @@ -24,3 +24,137 @@ try: except ImportError: #noinspection PyCompatibility from urllib2 import urlopen + + +try: + from collections import OrderedDict +except ImportError: + ### Python 2.6 OrderedDict class, needed for headers, parameters, etc .### + ### + # noinspection PyCompatibility + from UserDict import DictMixin + + class OrderedDict(dict, DictMixin): + # Copyright (c) 2009 Raymond Hettinger + # + # Permission is hereby granted, free of charge, to any person + # obtaining a copy of this software and associated documentation files + # (the "Software"), to deal in the Software without restriction, + # including without limitation the rights to use, copy, modify, merge, + # publish, distribute, sublicense, and/or sell copies of the Software, + # and to permit persons to whom the Software is furnished to do so, + # subject to the following conditions: + # + # The above copyright notice and this permission notice shall be + # included in all copies or substantial portions of the Software. + # + # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + # OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + # OTHER DEALINGS IN THE SOFTWARE. + def __init__(self, *args, **kwds): + if len(args) > 1: + raise TypeError('expected at most 1 arguments, got %d' + % len(args)) + try: + self.__end + except AttributeError: + self.clear() + self.update(*args, **kwds) + + def clear(self): + self.__end = end = [] + end += [None, end, end] # sentinel node for doubly linked list + self.__map = {} # key --> [key, prev, next] + dict.clear(self) + + def __setitem__(self, key, value): + if key not in self: + end = self.__end + curr = end[1] + curr[2] = end[1] = self.__map[key] = [key, curr, end] + dict.__setitem__(self, key, value) + + def __delitem__(self, key): + dict.__delitem__(self, key) + key, prev, next = self.__map.pop(key) + prev[2] = next + next[1] = prev + + def __iter__(self): + end = self.__end + curr = end[2] + while curr is not end: + yield curr[0] + curr = curr[2] + + def __reversed__(self): + end = self.__end + curr = end[1] + while curr is not end: + yield curr[0] + curr = curr[1] + + def popitem(self, last=True): + if not self: + raise KeyError('dictionary is empty') + if last: + key = reversed(self).next() + else: + key = iter(self).next() + value = self.pop(key) + return key, value + + def __reduce__(self): + items = [[k, self[k]] for k in self] + tmp = self.__map, self.__end + del self.__map, self.__end + inst_dict = vars(self).copy() + self.__map, self.__end = tmp + if inst_dict: + return self.__class__, (items,), inst_dict + return self.__class__, (items,) + + def keys(self): + return list(self) + + setdefault = DictMixin.setdefault + update = DictMixin.update + pop = DictMixin.pop + values = DictMixin.values + items = DictMixin.items + iterkeys = DictMixin.iterkeys + itervalues = DictMixin.itervalues + iteritems = DictMixin.iteritems + + def __repr__(self): + if not self: + return '%s()' % (self.__class__.__name__,) + return '%s(%r)' % (self.__class__.__name__, self.items()) + + def copy(self): + return self.__class__(self) + + @classmethod + def fromkeys(cls, iterable, value=None): + d = cls() + for key in iterable: + d[key] = value + return d + + def __eq__(self, other): + if isinstance(other, OrderedDict): + if len(self) != len(other): + return False + for p, q in zip(self.items(), other.items()): + if p != q: + return False + return True + return dict.__eq__(self, other) + + def __ne__(self, other): + return not self == other diff --git a/httpie/input.py b/httpie/input.py index 54f9a72c..f61576a7 100644 --- a/httpie/input.py +++ b/httpie/input.py @@ -10,11 +10,7 @@ import getpass from io import BytesIO #noinspection PyCompatibility from argparse import ArgumentParser, ArgumentTypeError, ArgumentError - -try: - from collections import OrderedDict -except ImportError: - OrderedDict = dict +from .compat import OrderedDict # TODO: Use MultiDict for headers once added to `requests`. # https://github.com/jkbr/httpie/issues/130 @@ -157,6 +153,7 @@ class Parser(ArgumentParser): # noinspection PyShadowingBuiltins def _print_message(self, message, file=None): # Sneak in our stderr/stdout. + print(file) file = { sys.stdout: self.env.stdout, sys.stderr: self.env.stderr, diff --git a/tests/test_httpie.py b/tests/test_httpie.py index 148210bc..d855fc4d 100644 --- a/tests/test_httpie.py +++ b/tests/test_httpie.py @@ -22,7 +22,8 @@ class HTTPieTest(TestCase): def test_version(self): r = http('--version') assert r.exit_status == httpie.ExitStatus.ERROR - assert httpie.__version__ == r.stderr.strip() + # FIXME: py3 has version in stdout, py2 in stderr + assert httpie.__version__ == r.stderr.strip() + r.strip() def test_GET(self): r = http('GET', httpbin('/get')) diff --git a/tests/test_output.py b/tests/test_output.py index 3d1d6c31..4d362267 100644 --- a/tests/test_output.py +++ b/tests/test_output.py @@ -15,8 +15,7 @@ class VerboseFlagTest(TestCase): r = http('--verbose', '--form', 'POST', httpbin('/post'), 'A=B', 'C=D') assert HTTP_OK in r - # Python 2.6 has no ordered dict, so we test for both orders here. - assert 'A=B&C=D' in r or 'C=D&A=B', r + assert 'A=B&C=D' in r def test_verbose_json(self): r = http('--verbose', 'POST', httpbin('/post'), 'foo=bar', 'baz=bar')