Commits

Germano Gabbianelli committed 493d652

Added dbf.sorteddict, django is no more needed to use pyDBF.

Comments (0)

Files changed (4)

 import datetime
 import struct
 
-from django.utils.datastructures import SortedDict
-
 from dbf import fields
+from dbf.sorteddict import SortedDict
 
 class DBF(object):
 
 import types
 import copy
 
-from django.utils.datastructures import SortedDict
-
 from dbf.base import DBF
+from dbf.sorteddict import SortedDict
 from dbf import fields
 
 class QuerySet(object):
+try:
+    from django.utils.datastructures import SortedDict
+except ImportError:
+    # code taken from django.utils.datastructures
+    class SortedDict(dict):
+        """
+        A dictionary that keeps its keys in the order in which they're inserted.
+        """
+        def __init__(self, data=None):
+            if data is None:
+                data = {}
+            super(SortedDict, self).__init__(data)
+            if isinstance(data, dict):
+                self.keyOrder = data.keys()
+            else:
+                self.keyOrder = []
+                for key, value in data:
+                    if key not in self.keyOrder:
+                        self.keyOrder.append(key)
+
+        def __deepcopy__(self, memo):
+            from copy import deepcopy
+            return self.__class__([(key, deepcopy(value, memo))
+                                   for key, value in self.iteritems()])
+
+        def __setitem__(self, key, value):
+            super(SortedDict, self).__setitem__(key, value)
+            if key not in self.keyOrder:
+                self.keyOrder.append(key)
+
+        def __delitem__(self, key):
+            super(SortedDict, self).__delitem__(key)
+            self.keyOrder.remove(key)
+
+        def __iter__(self):
+            for k in self.keyOrder:
+                yield k
+
+        def pop(self, k, *args):
+            result = super(SortedDict, self).pop(k, *args)
+            try:
+                self.keyOrder.remove(k)
+            except ValueError:
+                # Key wasn't in the dictionary in the first place. No problem.
+                pass
+            return result
+
+        def popitem(self):
+            result = super(SortedDict, self).popitem()
+            self.keyOrder.remove(result[0])
+            return result
+
+        def items(self):
+            return zip(self.keyOrder, self.values())
+
+        def iteritems(self):
+            for key in self.keyOrder:
+                yield key, super(SortedDict, self).__getitem__(key)
+
+        def keys(self):
+            return self.keyOrder[:]
+
+        def iterkeys(self):
+            return iter(self.keyOrder)
+
+        def values(self):
+            return [super(SortedDict, self).__getitem__(k) for k in self.keyOrder]
+
+        def itervalues(self):
+            for key in self.keyOrder:
+                yield super(SortedDict, self).__getitem__(key)
+
+        def update(self, dict_):
+            for k, v in dict_.items():
+                self.__setitem__(k, v)
+
+        def setdefault(self, key, default):
+            if key not in self.keyOrder:
+                self.keyOrder.append(key)
+            return super(SortedDict, self).setdefault(key, default)
+
+        def value_for_index(self, index):
+            """Returns the value of the item at the given zero-based index."""
+            return self[self.keyOrder[index]]
+
+        def insert(self, index, key, value):
+            """Inserts the key, value pair before the item with the given index."""
+            if key in self.keyOrder:
+                n = self.keyOrder.index(key)
+                del self.keyOrder[n]
+                if n < index:
+                    index -= 1
+            self.keyOrder.insert(index, key)
+            super(SortedDict, self).__setitem__(key, value)
+
+        def copy(self):
+            """Returns a copy of this object."""
+            # This way of initializing the copy means it works for subclasses, too.
+            obj = self.__class__(self)
+            obj.keyOrder = self.keyOrder[:]
+            return obj
+
+        def __repr__(self):
+            """
+            Replaces the normal dict.__repr__ with a version that returns the keys
+            in their sorted order.
+            """
+            return '{%s}' % ', '.join(['%r: %r' % (k, v) for k, v in self.items()])
+
+        def clear(self):
+            super(SortedDict, self).clear()
+            self.keyOrder = []
+
 
 setup(
     name='pyDBF',
-    version='0.1a.dev-r2',
+    version='0.1a.dev',
     description='Search, read and write Dbase and Xbase files',
     author='Tyrion MX',
     author_email='tyrion.mx@gmail.com',