home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / util / primitives / mapping.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  24.7 KB  |  770 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import funcs
  5. import functional
  6. import itertools
  7. from UserDict import DictMixin
  8.  
  9. try:
  10.     sentinel
  11. except NameError:
  12.     
  13.     class Sentinel(object):
  14.         
  15.         def __repr__(self):
  16.             return '<Sentinel (%r backup) %#x>' % (__file__, id(self))
  17.  
  18.  
  19.     sentinel = Sentinel()
  20.  
  21.  
  22. def fmt_to_dict(delim1, delim2):
  23.     
  24.     class dictifier('dictifier', (dict,)):
  25.         
  26.         def __init__(self, *a, **k):
  27.             if a and isinstance(a[0], basestring):
  28.                 dict.__init__(self, self.parse(a[0]), *a[1:], **k)
  29.             else:
  30.                 dict.__init__(self, *a, **k)
  31.  
  32.         
  33.         def parse(cls, s):
  34.             pairs = (list,)((lambda .0: for entry in .0:
  35. entry.strip().split(delim2, 1))(s.split(delim1)))
  36.             if len(pairs[-1]) == 1 and pairs[-1][0].strip() == '':
  37.                 pairs = pairs[:-1]
  38.             
  39.             return pairs
  40.  
  41.         parse = (None, classmethod)(parse)
  42.         
  43.         def __str__(self):
  44.             return (delim1.join,)((lambda .0: for i in .0:
  45. delim2.join(i))(self.items()))
  46.  
  47.  
  48.     return dictifier
  49.  
  50.  
  51. def dictreverse(mapping):
  52.     return dict((lambda .0: for key, value in .0:
  53. (value, key))(mapping.iteritems()))
  54.  
  55.  
  56. def dictadd(dict_a, dict_b):
  57.     result = dict(dict_a)
  58.     result.update(dict_b)
  59.     return result
  60.  
  61.  
  62. def dictsub(a, b):
  63.     a = a.copy()
  64.     for key in b:
  65.         a.pop(key, None)
  66.     
  67.     return a
  68.  
  69.  
  70. def dictdiff(defaults, user):
  71.     diff = { }
  72.     for k, v in user.iteritems():
  73.         if k not in defaults or v != defaults[k]:
  74.             diff[k] = v
  75.             continue
  76.     
  77.     return diff
  78.  
  79.  
  80. def intdictdiff(start, end):
  81.     keys = set(start.keys()) | set(end.keys())
  82.     out = { }
  83.     for key in keys:
  84.         startval = start.get(key, 0)
  85.         endval = end.get(key, 0)
  86.         outval = endval - startval
  87.         if outval:
  88.             out[key] = outval
  89.             continue
  90.     
  91.     return out
  92.  
  93.  
  94. class DictChain(functional.AttrChain, dict):
  95.     
  96.     def __init__(self, *args, **kwargs):
  97.         dict.__init__(self, *args, **kwargs)
  98.         functional.AttrChain.__init__(self, 'base', self.__getattr2__)
  99.  
  100.     
  101.     def __getattr2__(self, key):
  102.         keys = None if isinstance(key, basestring) else key
  103.         next = self[keys[0]]
  104.         if len(keys) > 1 and isinstance(next, DictChain):
  105.             return dict.__getattribute__(next, '__getattr2__')(keys[1:])
  106.         if keys:
  107.             
  108.             try:
  109.                 returner = next
  110.             except:
  111.                 isinstance(next, DictChain)
  112.                 return self['generic'][keys[0]]
  113.  
  114.             if isinstance(returner, DictChain):
  115.                 return returner['value']
  116.             return returner
  117.         keys
  118.         return self['value']
  119.  
  120.  
  121.  
  122. class Storage(dict):
  123.     
  124.     def __getattr__(self, key, ga = dict.__getattribute__, gi = None):
  125.         
  126.         try:
  127.             return ga(self, key)
  128.         except AttributeError:
  129.             
  130.             try:
  131.                 if gi is not None:
  132.                     return gi(self, key)
  133.                 return self[key]
  134.             except KeyError:
  135.                 msg = repr(key)
  136.                 if len(self) <= 20:
  137.                     keys = sorted(self.keys())
  138.                     msg += '\n  (%d existing keys: ' % len(keys) + str(keys) + ')'
  139.                 
  140.                 raise AttributeError, msg
  141.             except:
  142.                 None<EXCEPTION MATCH>KeyError
  143.             
  144.  
  145.             None<EXCEPTION MATCH>KeyError
  146.  
  147.  
  148.     
  149.     def __setattr__(self, key, value):
  150.         self[key] = value
  151.  
  152.     
  153.     def copy(self):
  154.         return type(self)(self)
  155.  
  156.  
  157.  
  158. def dictrecurse(newtype):
  159.     
  160.     def recurser(_d, forbidden = (None, ())):
  161.         if not hasattr(_d, 'keys'):
  162.             pformat = pformat
  163.             import pprint
  164.             raise TypeError('what is?\n%s' % pformat(_d))
  165.         hasattr(_d, 'keys')
  166.         for k in _d:
  167.             if isinstance(_d[k], dict):
  168.                 _d[k] = recurser(_d[k])
  169.                 continue
  170.             if funcs.isiterable(_d[k]) and not isinstance(_d[k], forbidden + (basestring,)):
  171.                 if isinstance(_d[k], tuple):
  172.                     t = tuple
  173.                 else:
  174.                     t = list
  175.                 _d[k] = (t,)((lambda .0: for item in .0:
  176. None if isinstance(item, dict) else item)(_d[k]))
  177.                 continue
  178.         
  179.         if isinstance(newtype, type):
  180.             if type(_d) is newtype:
  181.                 return _d
  182.             return newtype(_d)
  183.         return newtype(_d)
  184.  
  185.     return recurser
  186.  
  187. to_storage = dictrecurse(Storage)
  188.  
  189. def from_storage(d):
  190.     for k, v in d.items():
  191.         if isinstance(v, Storage):
  192.             d[k] = from_storage(v)
  193.             continue
  194.         if isinstance(v, list):
  195.             newlist = [ _[1] if isinstance(e, Storage) else e for e in d[k] ]
  196.             d[k] = newlist
  197.             continue
  198.         []
  199.     
  200.     if type(d) is dict:
  201.         return d
  202.     return dict(d)
  203.  
  204.  
  205. def lookup_table(*a, **d):
  206.     d = dict(*a, **d)
  207.     d.update(dictreverse(d))
  208.     return to_storage(d)
  209.  
  210.  
  211. class get_change_dict(dict):
  212.     
  213.     def __init__(self, *a, **k):
  214.         self.__dict__['_get_change_dict__get_change'] = k.pop('_get_change', None)
  215.         super(get_change_dict, self).__init__(*a, **k)
  216.  
  217.     
  218.     def __getitem__(self, key):
  219.         if getattr(self, '_get_change_dict__get_change', None) is not None:
  220.             key = self._get_change_dict__get_change(key)
  221.         
  222.         return super(get_change_dict, self).__getitem__(key)
  223.  
  224.     
  225.     def __contains__(self, key):
  226.         if self._get_change_dict__get_change is not None:
  227.             key = self._get_change_dict__get_change(key)
  228.         
  229.         return super(get_change_dict, self).__contains__(key)
  230.  
  231.     
  232.     def pop(self, key, x = None):
  233.         key = self._get_change_dict__get_change(key)
  234.         return super(get_change_dict, self).pop(key, x)
  235.  
  236.  
  237.  
  238. class set_change_dict(dict):
  239.     
  240.     def __init__(self, *a, **k):
  241.         self.__dict__['_set_change_dict__set_change'] = k.pop('_set_change', None)
  242.         super(set_change_dict, self).__init__(*a, **k)
  243.  
  244.     
  245.     def __setitem__(self, key, val):
  246.         if getattr(self, '_set_change_dict__set_change', None) is not None:
  247.             key = self._set_change_dict__set_change(key)
  248.         
  249.         return super(set_change_dict, self).__setitem__(key, val)
  250.  
  251.     
  252.     def setdefault(self, key, default):
  253.         if self._set_change_dict__key_change is not None:
  254.             key = self._set_change_dict__key_change(key)
  255.         
  256.         
  257.         try:
  258.             return super(set_change_dict, self).__getitem__(key.lower())
  259.         except KeyError:
  260.             super(set_change_dict, self).__setitem__(key.lower(), default)
  261.             return default
  262.  
  263.  
  264.  
  265.  
  266. class key_change_dict(set_change_dict, get_change_dict):
  267.     
  268.     def __init__(self, *a, **k):
  269.         self.__dict__['_key_change_dict__key_change'] = _key_change = k.pop('_key_change', None)
  270.         k['_set_change'] = _key_change
  271.         k['_get_change'] = _key_change
  272.         super(key_change_dict, self).__init__(*a, **k)
  273.  
  274.  
  275.  
  276. class lower_case_dict(key_change_dict):
  277.     
  278.     def __init__(self, *a, **k):
  279.         self.__dict__['_lower_case_dict__key_change'] = k['_key_change'] = (lambda key: key.lower())
  280.         super(lower_case_dict, self).__init__(*a, **k)
  281.         for key in list(self.keys()):
  282.             self[key] = super(lower_case_dict, self).pop(key)
  283.         
  284.  
  285.     
  286.     def __delitem__(self, key):
  287.         key = self._lower_case_dict__key_change(key)
  288.         return super(lower_case_dict, self).__delitem__(key)
  289.  
  290.  
  291.  
  292. class no_case_dict(set_change_dict, get_change_dict):
  293.     
  294.     def __init__(self, *a, **k):
  295.         self.__dict__['_no_case_dict__mapping'] = { }
  296.         k['_set_change'] = self._no_case_dict__set_change
  297.         k['_get_change'] = self._no_case_dict__get_change
  298.         super(no_case_dict, self).__init__(*a, **k)
  299.         self.__dict__['_no_case_dict__inited'] = False
  300.         for key in list(self.keys()):
  301.             self[key] = self.pop(key)
  302.         
  303.         self.__dict__['_no_case_dict__inited'] = True
  304.  
  305.     
  306.     def __set_change(self, key):
  307.         self._no_case_dict__mapping[key.lower()] = key
  308.         return key
  309.  
  310.     
  311.     def __get_change(self, key):
  312.         if self._no_case_dict__inited:
  313.             key = self._no_case_dict__mapping[key.lower()]
  314.         
  315.         return key
  316.  
  317.  
  318.  
  319. def stringify_dict(dict):
  320.     new = { }
  321.     for k, v in dict.items():
  322.         if isinstance(k, basestring):
  323.             new[str(k)] = v
  324.             continue
  325.         new[k] = v
  326.     
  327.     return new
  328.  
  329.  
  330. class odict(dict):
  331.     
  332.     def __init__(self, d = None):
  333.         if d is None:
  334.             d = { }
  335.         
  336.         
  337.         try:
  338.             t = d.items()
  339.             self._keys = [ k for k, _v in t ]
  340.             dict.__init__(self, t)
  341.         except:
  342.             (one, two, three) = itertools.tee(d, 3)
  343.             
  344.             try:
  345.                 self._keys = [ k for k, _v in one ]
  346.             except:
  347.                 self._keys = [ k for k in two ]
  348.  
  349.             [](dict.__init__, self if isinstance(d, dict) else three)
  350.  
  351.  
  352.     
  353.     def __delitem__(self, key):
  354.         dict.__delitem__(self, key)
  355.         self._keys.remove(key)
  356.  
  357.     
  358.     def __setitem__(self, key, item):
  359.         dict.__setitem__(self, key, item)
  360.         if not hasattr(self, '_keys'):
  361.             self._keys = [
  362.                 key]
  363.         
  364.         if key not in self._keys:
  365.             self._keys.append(key)
  366.         
  367.  
  368.     __iter__ = property((lambda self: self._keys.__iter__))
  369.     
  370.     def clear(self):
  371.         dict.clear(self)
  372.         self._keys = []
  373.  
  374.     
  375.     def pop(self, k, defval = sentinel):
  376.         
  377.         try:
  378.             val = dict.pop(self, k)
  379.         except KeyError:
  380.             if defval is sentinel:
  381.                 raise 
  382.             defval is sentinel
  383.             return defval
  384.  
  385.         self._keys.remove(k)
  386.         return val
  387.  
  388.     
  389.     def iteritems(self):
  390.         for i in self._keys:
  391.             
  392.             try:
  393.                 yield (i, self[i])
  394.             continue
  395.             except KeyError:
  396.                 print 'fake keys', self._keys
  397.                 print 'real keys', self.keys()
  398.                 raise 
  399.                 continue
  400.             
  401.  
  402.         
  403.  
  404.     
  405.     def items(self):
  406.         return list(self.iteritems())
  407.  
  408.     
  409.     def keys(self):
  410.         return self._keys[:]
  411.  
  412.     
  413.     def iterkeys(self):
  414.         return iter(self._keys)
  415.  
  416.     
  417.     def itervalues(self):
  418.         for i in self._keys:
  419.             yield self[i]
  420.         
  421.  
  422.     
  423.     def values(self):
  424.         return list(self.itervalues())
  425.  
  426.     
  427.     def popitem(self):
  428.         if len(self._keys) == 0:
  429.             raise KeyError('dictionary is empty')
  430.         len(self._keys) == 0
  431.         key = self._keys[-1]
  432.         val = self[key]
  433.         del self[key]
  434.         return (key, val)
  435.  
  436.     
  437.     def setdefault(self, key, failobj = None):
  438.         ret = dict.setdefault(self, key, failobj)
  439.         if key not in self._keys:
  440.             self._keys.append(key)
  441.         
  442.         return ret
  443.  
  444.     
  445.     def update(self, d):
  446.         
  447.         try:
  448.             for key in d.keys():
  449.                 if not self.has_key(key):
  450.                     self._keys.append(key)
  451.                     continue
  452.         except AttributeError:
  453.             for k, v in d:
  454.                 self[k] = v
  455.             
  456.             return None
  457.  
  458.         dict.update(self, d)
  459.  
  460.     
  461.     def move(self, key, index):
  462.         
  463.         try:
  464.             cur = self._keys.index(key)
  465.         except ValueError:
  466.             raise KeyError(key)
  467.  
  468.         self._keys.insert(index, key)
  469.         if cur >= index:
  470.             cur = cur + 1
  471.         
  472.         del self._keys[cur]
  473.  
  474.     
  475.     def index(self, key):
  476.         if not self.has_key(key):
  477.             raise KeyError(key)
  478.         self.has_key(key)
  479.         return self._keys.index(key)
  480.  
  481.     
  482.     def get(self, key, default = None):
  483.         return dict.get(self, key, default)
  484.  
  485.     
  486.     def sort(self, cmp = None, key = None, reverse = False):
  487.         return self._keys.sort(cmp = cmp, key = key, reverse = reverse)
  488.  
  489.     
  490.     def sort_values(self, cmp = None, key = None, reverse = False):
  491.         if key is None:
  492.             
  493.             key = lambda k: k
  494.         
  495.         
  496.         value_key = lambda k: key(self.get(k))
  497.         self.sort(cmp = cmp, key = value_key, reverse = reverse)
  498.  
  499.  
  500.  
  501. class OrderedDict(dict, DictMixin):
  502.     
  503.     def __init__(self, *args, **kwds):
  504.         if len(args) > 1:
  505.             raise TypeError('expected at most 1 arguments, got %d' % len(args))
  506.         len(args) > 1
  507.         
  508.         try:
  509.             self._OrderedDict__end
  510.         except AttributeError:
  511.             self.clear()
  512.  
  513.         self.update(*args, **kwds)
  514.  
  515.     
  516.     def clear(self):
  517.         self._OrderedDict__end = end = []
  518.         end += [
  519.             None,
  520.             end,
  521.             end]
  522.         self._OrderedDict__map = { }
  523.         dict.clear(self)
  524.  
  525.     
  526.     def __setitem__(self, key, value):
  527.         if key not in self:
  528.             end = self._OrderedDict__end
  529.             curr = end[1]
  530.             curr[2] = end[1] = self._OrderedDict__map[key] = [
  531.                 key,
  532.                 curr,
  533.                 end]
  534.         
  535.         dict.__setitem__(self, key, value)
  536.  
  537.     
  538.     def __delitem__(self, key):
  539.         dict.__delitem__(self, key)
  540.         (key, prev, next) = self._OrderedDict__map.pop(key)
  541.         prev[2] = next
  542.         next[1] = prev
  543.  
  544.     
  545.     def __iter__(self):
  546.         end = self._OrderedDict__end
  547.         curr = end[2]
  548.         while curr is not end:
  549.             yield curr[0]
  550.             curr = curr[2]
  551.  
  552.     
  553.     def __reversed__(self):
  554.         end = self._OrderedDict__end
  555.         curr = end[1]
  556.         while curr is not end:
  557.             yield curr[0]
  558.             curr = curr[1]
  559.  
  560.     
  561.     def popitem(self, last = True):
  562.         if not self:
  563.             raise KeyError('dictionary is empty')
  564.         self
  565.         key = None if last else iter(self).next()
  566.         value = self.pop(key)
  567.         return (key, value)
  568.  
  569.     
  570.     def __reduce__(self):
  571.         items = [ [
  572.             k,
  573.             self[k]] for k in self ]
  574.         tmp = (self._OrderedDict__map, self._OrderedDict__end)
  575.         del self._OrderedDict__map
  576.         del self._OrderedDict__end
  577.         inst_dict = vars(self).copy()
  578.         (self._OrderedDict__map, self._OrderedDict__end) = tmp
  579.         if inst_dict:
  580.             return (self.__class__, (items,), inst_dict)
  581.         return (self.__class__, (items,))
  582.  
  583.     
  584.     def keys(self):
  585.         return list(self)
  586.  
  587.     setdefault = DictMixin.setdefault
  588.     update = DictMixin.update
  589.     pop = DictMixin.pop
  590.     values = DictMixin.values
  591.     items = DictMixin.items
  592.     iterkeys = DictMixin.iterkeys
  593.     itervalues = DictMixin.itervalues
  594.     iteritems = DictMixin.iteritems
  595.     
  596.     def __repr__(self):
  597.         if not self:
  598.             return '%s()' % (self.__class__.__name__,)
  599.         return '%s(%r)' % (self.__class__.__name__, self.items())
  600.  
  601.     
  602.     def copy(self):
  603.         return self.__class__(self)
  604.  
  605.     
  606.     def fromkeys(cls, iterable, value = None):
  607.         d = cls()
  608.         for key in iterable:
  609.             d[key] = value
  610.         
  611.         return d
  612.  
  613.     fromkeys = classmethod(fromkeys)
  614.     
  615.     def __eq__(self, other):
  616.         if isinstance(other, OrderedDict):
  617.             if len(self) == len(other):
  618.                 pass
  619.             return all((lambda .0: for p, q in .0:
  620. p == q)(zip(self.items(), other.items())))
  621.         return dict.__eq__(self, other)
  622.  
  623.     
  624.     def __ne__(self, other):
  625.         return not (self == other)
  626.  
  627.  
  628.  
  629. class LazySortedDict(odict):
  630.     
  631.     def _get_keys(self):
  632.         
  633.         try:
  634.             self._real_keys = sorted(self._real_keys)
  635.         except AttributeError:
  636.             self._real_keys = []
  637.  
  638.         return self._real_keys
  639.  
  640.     
  641.     def _set_keys(self, keys):
  642.         self._real_keys = sorted(keys)
  643.  
  644.     
  645.     def copy(self):
  646.         return type(self)(self)
  647.  
  648.     _keys = property(_get_keys, _set_keys)
  649.  
  650.  
  651. class ostorage(odict, Storage):
  652.     
  653.     def __getattr__(self, attr):
  654.         if attr == '_keys':
  655.             return odict.__getattr__(self, attr)
  656.         return Storage.__getattr__(self, attr)
  657.  
  658.     
  659.     def __setattr__(self, attr, val):
  660.         if attr == '_keys':
  661.             return odict.__setattr__(self, attr, val)
  662.         return Storage.__setattr__(self, attr, val)
  663.  
  664.  
  665.  
  666. class Ostorage(OrderedDict, Storage):
  667.     
  668.     def __getattr__(self, attr):
  669.         if attr in ('_OrderedDict__map', '_OrderedDict__end'):
  670.             return OrderedDict.__getattr__(self, attr)
  671.         return Storage.__getattr__(self, attr)
  672.  
  673.     
  674.     def __setattr__(self, attr, val):
  675.         if attr in ('_OrderedDict__map', '_OrderedDict__end'):
  676.             return OrderedDict.__setattr__(self, attr, val)
  677.         return Storage.__setattr__(self, attr, val)
  678.  
  679.  
  680.  
  681. def groupify(seq, keys = None, whitelist = True, mapclass = odict):
  682.     retval = [
  683.         mapclass()]
  684.     idx = 0
  685.     for k, v in seq:
  686.         if keys and whitelist ^ (k in keys):
  687.             continue
  688.         
  689.         if k in retval[idx]:
  690.             retval.append(mapclass())
  691.             idx += 1
  692.         
  693.         retval[idx][k] = v
  694.     
  695.     if not retval[0]:
  696.         return []
  697.     return retval
  698.  
  699.  
  700. class FilterDict(dict):
  701.     
  702.     def __init__(self, filterfunc, d = None, **kw):
  703.         if d is None:
  704.             d = { }
  705.         
  706.         dict.__init__(self)
  707.         d.update(kw)
  708.         dict.__setattr__(self, 'ff', filterfunc)
  709.         for k, v in d.iteritems():
  710.             self.__setitem__(k, v)
  711.         
  712.  
  713.     
  714.     def __getitem__(self, key):
  715.         return dict.__getitem__(self, self.ff(key))
  716.  
  717.     
  718.     def __delitem__(self, key):
  719.         return dict.__delitem__(self, self.ff(key))
  720.  
  721.     
  722.     def __contains__(self, key):
  723.         return dict.__contains__(self, self.ff(key))
  724.  
  725.     
  726.     def __setitem__(self, key, newval):
  727.         return dict.__setitem__(self, self.ff(key), newval)
  728.  
  729.  
  730.  
  731. class LowerDict(FilterDict):
  732.     
  733.     def __init__(self, *a, **k):
  734.         
  735.         def filterfunc(x):
  736.             
  737.             try:
  738.                 x = x.lower()
  739.             except:
  740.                 pass
  741.  
  742.             return x
  743.  
  744.         FilterDict.__init__(self, filterfunc, *a, **k)
  745.  
  746.  
  747. recurse_lower = dictrecurse(LowerDict)
  748.  
  749. class LowerStorage(LowerDict, Storage):
  750.     
  751.     def __init__(self, *a, **k):
  752.         Storage.__init__(self)
  753.         LowerDict.__init__(self, *a, **k)
  754.  
  755.  
  756. recurse_lower_storage = dictrecurse(LowerStorage)
  757.  
  758. def odict_from_dictlist(seq):
  759.     od = odict()
  760.     for subdict in seq:
  761.         key = subdict.keys()[0]
  762.         od[key] = subdict[key]
  763.     
  764.     return od
  765.  
  766. if __name__ == '__main__':
  767.     import doctest
  768.     doctest.testmod(verbose = True)
  769.  
  770.