Mercurial > kallithea

changeset 7789:75b128508fa8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
compat: use collections.OrderedDict - we only support Python 2.7 and no longer need our own implementation
author Mads Kiilerich <mads@kiilerich.com>
date Sun, 21 Jul 2019 19:12:20 +0200
parents 3ea66ef563f2
children 469b16f3979a
files kallithea/controllers/changeset.py kallithea/controllers/files.py kallithea/lib/celerylib/tasks.py kallithea/lib/compat.py kallithea/lib/vcs/backends/git/repository.py kallithea/lib/vcs/backends/hg/repository.py kallithea/lib/vcs/utils/ordered_dict.py
diffstat 7 files changed, 6 insertions(+), 388 deletions(-) [+]
line wrap: on
line diff
--- a/kallithea/controllers/changeset.py	Wed Jul 31 03:15:06 2019 +0200
+++ b/kallithea/controllers/changeset.py	Sun Jul 21 19:12:20 2019 +0200
@@ -27,7 +27,7 @@
 
 import logging
 import traceback
-from collections import defaultdict
+from collections import defaultdict, OrderedDict
 
 from tg import tmpl_context as c, request, response
 from tg.i18n import ugettext as _
@@ -40,7 +40,6 @@
 from kallithea.lib.auth import LoginRequired, HasRepoPermissionLevelDecorator
 from kallithea.lib.base import BaseRepoController, render, jsonify
 from kallithea.lib.utils import action_logger
-from kallithea.lib.compat import OrderedDict
 from kallithea.lib import diffs
 from kallithea.model.db import ChangesetComment, ChangesetStatus
 from kallithea.model.comment import ChangesetCommentsModel
--- a/kallithea/controllers/files.py	Wed Jul 31 03:15:06 2019 +0200
+++ b/kallithea/controllers/files.py	Sun Jul 21 19:12:20 2019 +0200
@@ -31,6 +31,7 @@
 import traceback
 import tempfile
 import shutil
+from collections import OrderedDict
 
 from tg import request, response, tmpl_context as c
 from tg.i18n import ugettext as _
@@ -41,7 +42,6 @@
 from kallithea.lib import diffs
 from kallithea.lib import helpers as h
 
-from kallithea.lib.compat import OrderedDict
 from kallithea.lib.utils2 import convert_line_endings, detect_mode, safe_str, \
     str2bool, safe_int
 from kallithea.lib.auth import LoginRequired, HasRepoPermissionLevelDecorator
--- a/kallithea/lib/celerylib/tasks.py	Wed Jul 31 03:15:06 2019 +0200
+++ b/kallithea/lib/celerylib/tasks.py	Sun Jul 21 19:12:20 2019 +0200
@@ -31,6 +31,7 @@
 import logging
 import rfc822
 
+from collections import OrderedDict
 from time import mktime
 from operator import itemgetter
 from string import lower
@@ -44,7 +45,7 @@
 from kallithea.lib.utils import action_logger
 from kallithea.lib.utils2 import str2bool
 from kallithea.lib.vcs.utils import author_email
-from kallithea.lib.compat import json, OrderedDict
+from kallithea.lib.compat import json
 from kallithea.lib.hooks import log_create_repository
 
 from kallithea.model.db import Statistics, RepoGroup, Repository, User
--- a/kallithea/lib/compat.py	Wed Jul 31 03:15:06 2019 +0200
+++ b/kallithea/lib/compat.py	Sun Jul 21 19:12:20 2019 +0200
@@ -50,285 +50,6 @@
 
 
 #==============================================================================
-# OrderedDict - Python 2.7 could perhaps use collections.OrderedDict
-#==============================================================================
-
-# Python Software Foundation License
-
-
-# XXX: it feels like using the class with "is" and "is not" instead of "==" and
-# "!=" should be faster.
-class _Nil(object):
-
-    def __repr__(self):
-        return "nil"
-
-    def __eq__(self, other):
-        if (isinstance(other, _Nil)):
-            return True
-        else:
-            return NotImplemented
-
-    def __ne__(self, other):
-        if (isinstance(other, _Nil)):
-            return False
-        else:
-            return NotImplemented
-
-
-_nil = _Nil()
-
-
-class OrderedDict(dict):
-    """Ordered dict data structure, with O(1) complexity for dict operations
-    that modify one element.
-
-    Overwriting values doesn't change their original sequential order.
-    """
-
-    def __init__(self, data=(), **kwds):
-        """This doesn't accept keyword initialization as normal dicts to avoid
-        a trap - inside a function or method the keyword args are accessible
-        only as a dict, without a defined order, so their original order is
-        lost.
-        """
-        if kwds:
-            raise TypeError("__init__() of ordered dict takes no keyword "
-                            "arguments to avoid an ordering trap.")
-        dict.__init__(self)
-        # If you give a normal dict, then the order of elements is undefined
-        if hasattr(data, "iteritems"):
-            for key, val in data.iteritems():
-                self[key] = val
-        else:
-            for key, val in data:
-                self[key] = val
-
-    # Double-linked list header
-    def _get_lh(self):
-        if not hasattr(self, '_lh'):
-            dict.__setattr__(self, '_lh', _nil)
-        return dict.__getattribute__(self, '_lh')
-
-    def _set_lh(self, val):
-        dict.__setattr__(self, '_lh', val)
-
-    lh = property(_get_lh, _set_lh)
-
-    # Double-linked list tail
-    def _get_lt(self):
-        if not hasattr(self, '_lt'):
-            dict.__setattr__(self, '_lt', _nil)
-        return dict.__getattribute__(self, '_lt')
-
-    def _set_lt(self, val):
-        dict.__setattr__(self, '_lt', val)
-
-    lt = property(_get_lt, _set_lt)
-
-    def __getitem__(self, key):
-        return dict.__getitem__(self, key)[1]
-
-    def __setitem__(self, key, val):
-        try:
-            dict.__getitem__(self, key)[1] = val
-        except KeyError:
-            new = [dict.__getattribute__(self, 'lt'), val, _nil]
-            dict.__setitem__(self, key, new)
-            if dict.__getattribute__(self, 'lt') == _nil:
-                dict.__setattr__(self, 'lh', key)
-            else:
-                dict.__getitem__(
-                    self, dict.__getattribute__(self, 'lt'))[2] = key
-            dict.__setattr__(self, 'lt', key)
-
-    def __delitem__(self, key):
-        pred, _, succ = dict.__getitem__(self, key)
-        if pred == _nil:
-            dict.__setattr__(self, 'lh', succ)
-        else:
-            dict.__getitem__(self, pred)[2] = succ
-        if succ == _nil:
-            dict.__setattr__(self, 'lt', pred)
-        else:
-            dict.__getitem__(self, succ)[0] = pred
-        dict.__delitem__(self, key)
-
-    def __contains__(self, key):
-        return key in self.keys()
-
-    def __len__(self):
-        return len(self.keys())
-
-    def __str__(self):
-        pairs = ("%r: %r" % (k, v) for k, v in self.iteritems())
-        return "{%s}" % ", ".join(pairs)
-
-    def __repr__(self):
-        if self:
-            pairs = ("(%r, %r)" % (k, v) for k, v in self.iteritems())
-            return "odict([%s])" % ", ".join(pairs)
-        else:
-            return "odict()"
-
-    def get(self, k, x=None):
-        if k in self:
-            return dict.__getitem__(self, k)[1]
-        else:
-            return x
-
-    def __iter__(self):
-        curr_key = dict.__getattribute__(self, 'lh')
-        while curr_key != _nil:
-            yield curr_key
-            curr_key = dict.__getitem__(self, curr_key)[2]
-
-    iterkeys = __iter__
-
-    def keys(self):
-        return list(self.iterkeys())
-
-    def itervalues(self):
-        curr_key = dict.__getattribute__(self, 'lh')
-        while curr_key != _nil:
-            _, val, curr_key = dict.__getitem__(self, curr_key)
-            yield val
-
-    def values(self):
-        return list(self.itervalues())
-
-    def iteritems(self):
-        curr_key = dict.__getattribute__(self, 'lh')
-        while curr_key != _nil:
-            _, val, next_key = dict.__getitem__(self, curr_key)
-            yield curr_key, val
-            curr_key = next_key
-
-    def items(self):
-        return list(self.iteritems())
-
-    def sort(self, cmp=None, key=None, reverse=False):
-        items = [(k, v) for k, v in self.items()]
-        if cmp is not None:
-            items = sorted(items, cmp=cmp)
-        elif key is not None:
-            items = sorted(items, key=key)
-        else:
-            items = sorted(items, key=lambda x: x[1])
-        if reverse:
-            items.reverse()
-        self.clear()
-        self.__init__(items)
-
-    def clear(self):
-        dict.clear(self)
-        dict.__setattr__(self, 'lh', _nil)
-        dict.__setattr__(self, 'lt', _nil)
-
-    def copy(self):
-        return self.__class__(self)
-
-    def update(self, data=(), **kwds):
-        if kwds:
-            raise TypeError("update() of ordered dict takes no keyword "
-                            "arguments to avoid an ordering trap.")
-        if hasattr(data, "iteritems"):
-            data = data.iteritems()
-        for key, val in data:
-            self[key] = val
-
-    def setdefault(self, k, x=None):
-        try:
-            return self[k]
-        except KeyError:
-            self[k] = x
-            return x
-
-    def pop(self, k, x=_nil):
-        try:
-            val = self[k]
-            del self[k]
-            return val
-        except KeyError:
-            if x == _nil:
-                raise
-            return x
-
-    def popitem(self):
-        try:
-            key = dict.__getattribute__(self, 'lt')
-            return key, self.pop(key)
-        except KeyError:
-            raise KeyError("'popitem(): ordered dictionary is empty'")
-
-    def riterkeys(self):
-        """To iterate on keys in reversed order.
-        """
-        curr_key = dict.__getattribute__(self, 'lt')
-        while curr_key != _nil:
-            yield curr_key
-            curr_key = dict.__getitem__(self, curr_key)[0]
-
-    __reversed__ = riterkeys
-
-    def rkeys(self):
-        """List of the keys in reversed order.
-        """
-        return list(self.riterkeys())
-
-    def ritervalues(self):
-        """To iterate on values in reversed order.
-        """
-        curr_key = dict.__getattribute__(self, 'lt')
-        while curr_key != _nil:
-            curr_key, val, _ = dict.__getitem__(self, curr_key)
-            yield val
-
-    def rvalues(self):
-        """List of the values in reversed order.
-        """
-        return list(self.ritervalues())
-
-    def riteritems(self):
-        """To iterate on (key, value) in reversed order.
-        """
-        curr_key = dict.__getattribute__(self, 'lt')
-        while curr_key != _nil:
-            pred_key, val, _ = dict.__getitem__(self, curr_key)
-            yield curr_key, val
-            curr_key = pred_key
-
-    def ritems(self):
-        """List of the (key, value) in reversed order.
-        """
-        return list(self.riteritems())
-
-    def firstkey(self):
-        if self:
-            return dict.__getattribute__(self, 'lh')
-        else:
-            raise KeyError("'firstkey(): ordered dictionary is empty'")
-
-    def lastkey(self):
-        if self:
-            return dict.__getattribute__(self, 'lt')
-        else:
-            raise KeyError("'lastkey(): ordered dictionary is empty'")
-
-    def as_dict(self):
-        return dict(self.items())
-
-    def _repr(self):
-        """_repr(): low level repr of the whole data contained in the odict.
-        Useful for debugging.
-        """
-        form = "odict low level repr lh,lt,data: %r, %r, %s"
-        return form % (dict.__getattribute__(self, 'lh'),
-                       dict.__getattribute__(self, 'lt'),
-                       dict.__repr__(self))
-
-
-#==============================================================================
 # OrderedSet
 #==============================================================================
 from sqlalchemy.util import OrderedSet
--- a/kallithea/lib/vcs/backends/git/repository.py	Wed Jul 31 03:15:06 2019 +0200
+++ b/kallithea/lib/vcs/backends/git/repository.py	Sun Jul 21 19:12:20 2019 +0200
@@ -17,6 +17,7 @@
 import urllib2
 import logging
 import posixpath
+from collections import OrderedDict
 
 from dulwich.objects import Tag
 from dulwich.repo import Repo, NotGitRepository
@@ -32,7 +33,6 @@
 )
 from kallithea.lib.vcs.utils import safe_str, safe_unicode, makedate, date_fromtimestamp
 from kallithea.lib.vcs.utils.lazy import LazyProperty
-from kallithea.lib.vcs.utils.ordered_dict import OrderedDict
 from kallithea.lib.vcs.utils.paths import abspath, get_user_home
 
 from kallithea.lib.vcs.utils.hgcompat import (
--- a/kallithea/lib/vcs/backends/hg/repository.py	Wed Jul 31 03:15:06 2019 +0200
+++ b/kallithea/lib/vcs/backends/hg/repository.py	Sun Jul 21 19:12:20 2019 +0200
@@ -15,9 +15,9 @@
 import urllib2
 import logging
 import datetime
+from collections import OrderedDict
 
 from kallithea.lib.vcs.backends.base import BaseRepository, CollectionGenerator
-
 from kallithea.lib.vcs.exceptions import (
     BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError,
     RepositoryError, VCSError, TagAlreadyExistError, TagDoesNotExistError
@@ -26,7 +26,6 @@
     author_email, author_name, date_fromtimestamp, makedate, safe_unicode, safe_str,
 )
 from kallithea.lib.vcs.utils.lazy import LazyProperty
-from kallithea.lib.vcs.utils.ordered_dict import OrderedDict
 from kallithea.lib.vcs.utils.paths import abspath
 from kallithea.lib.vcs.utils.hgcompat import (
     ui, nullid, match, match_exact, patch, diffopts, clone, get_contact,
--- a/kallithea/lib/vcs/utils/ordered_dict.py	Wed Jul 31 03:15:06 2019 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,102 +0,0 @@
-"""Ordered dict implementation"""
-from UserDict import DictMixin
-
-
-class OrderedDict(dict, DictMixin):
-
-    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):
-            return len(self) == len(other) and self.items() == other.items()
-        return dict.__eq__(self, other)
-
-    def __ne__(self, other):
-        return not self == other