1   
  2   
  3   
  4  """Implements a case-insensitive (on keys) dictionary and order-sensitive dictionary""" 
  5   
  6   
  7   
  8   
  9   
 10   
 11   
 12   
 13   
 14   
 15   
 16   
 17   
 18   
 19   
 20   
 21   
 22   
 23   
 25    """this uses the object's upper method - works with string and unicode""" 
 26    if str is None: return str 
 27    return str.upper() 
  28   
 31      """constructs the cidict, optionally using another dict to do so""" 
 32      if fromdict is not None: 
 33        self.update(fromdict) 
  34   
 36      if type(key) != str and type(key) != unicode: 
 37        raise TypeError, "cidict can only have str or unicode as key (got %r)" % type(key) 
 38      for akey in self.iterkeys(): 
 39        if akey.lower() == key.lower(): 
 40          return dict.__getitem__(self, akey) 
 41      raise IndexError 
  42   
 50   
 52      """D.update(E) -> None.  Update D from E: for k in E.keys(): D[k] = E[k]""" 
 53      for key, value in updatedict.iteritems(): 
 54        self[key] = value 
  55   
 57      if type(key) != str and type(key) != unicode: 
 58        raise TypeError, "cidict can only have str or unicode as key (got %r)" % type(key) 
 59      for akey in self.iterkeys(): 
 60        if akey.lower() == key.lower(): 
 61          return dict.__delitem__(self, akey) 
 62      raise IndexError 
  63   
 65      if type(key) != str and type(key) != unicode: 
 66        raise TypeError, "cidict can only have str or unicode as key (got %r)" % type(key) 
 67      for akey in self.iterkeys(): 
 68        if akey.lower() == key.lower(): 
 69          return 1 
 70      return 0 
  71   
 74   
 75 -  def get(self, key, default=None): 
  76      if self.has_key(key): 
 77        return self[key] 
 78      else: 
 79        return default 
  82    """a dictionary which remembers its keys in the order in which they were given""" 
 84      if len(args) == 0: 
 85        super(ordereddict, self).__init__() 
 86        self.order = [] 
 87      elif len(args) > 1: 
 88        raise TypeError("ordereddict() takes at most 1 argument (%d given)" % len(args)) 
 89      else: 
 90        initarg = args[0] 
 91        apply(super(ordereddict, self).__init__, args) 
 92        if hasattr(initarg, "keys"): 
 93          self.order = initarg.keys() 
 94        else: 
 95           
 96          self.order = [] 
 97          checkduplicates = {} 
 98          for key, value in initarg: 
 99            if not key in checkduplicates: 
100              self.order.append(key) 
101              checkduplicates[key] = None 
 102   
104      alreadypresent = key in self 
105      result = dict.__setitem__(self, key, value) 
106      if not alreadypresent: self.order.append(key) 
107      return result 
 108   
109 -  def update(self, updatedict): 
 110      """D.update(E) -> None.  Update D from E: for k in E.keys(): D[k] = E[k]""" 
111      for key, value in updatedict.iteritems(): 
112        self[key] = value 
 113   
115      alreadypresent = key in self 
116      result = dict.__delitem__(self, key) 
117      if alreadypresent: del self.order[self.order.index(key)] 
118      return result 
 119   
121      """D.copy() -> a shallow copy of D""" 
122      thecopy = ordereddict(super(ordereddict, self).copy()) 
123      thecopy.order = self.order[:] 
124      return thecopy 
 125   
127      """D.items() -> list of D's (key, value) pairs, as 2-tuples""" 
128      return [(key, self[key]) for key in self.order] 
 129   
131      """D.iteritems() -> an iterator over the (key, value) items of D""" 
132      for key in self.order: 
133        yield (key, self[key]) 
 134   
136      """D.iterkeys() -> an iterator over the keys of D""" 
137      for key in self.order: 
138        yield key 
 139   
140    __iter__ = iterkeys 
141   
143      """D.itervalues() -> an iterator over the values of D""" 
144      for key in self.order: 
145        yield self[key] 
 146   
148      """D.keys() -> list of D's keys""" 
149      return self.order[:] 
 150   
152      """D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple; but raise KeyError if D is empty""" 
153      if len(self.order) == 0: 
154        raise KeyError("popitem(): ordered dictionary is empty") 
155      k = self.order.pop() 
156      v = self[k] 
157      del self[k] 
158      return (k,v) 
 159   
160 -  def pop(self, key): 
 161      """remove entry from dict and internal list""" 
162      value = super(ordereddict, self).pop(key) 
163      del self.order[self.order.index(key)] 
164      return value 
  165