home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / util / primitives / mapping.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  16.0 KB  |  518 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import funcs
  5. import functional
  6. import itertools
  7.  
  8. try:
  9.     sentinel
  10. except NameError:
  11.     
  12.     class Sentinel(object):
  13.         
  14.         def __repr__(self):
  15.             return '<Sentinel (%r backup) %#x>' % (__file__, id(self))
  16.  
  17.  
  18.     sentinel = Sentinel()
  19.  
  20.  
  21. def fmt_to_dict(delim1, delim2):
  22.     
  23.     class dictifier('dictifier', (dict,)):
  24.         
  25.         def __init__(self, *a, **k):
  26.             if a and isinstance(a[0], basestring):
  27.                 dict.__init__(self, self.parse(a[0]), *a[1:], **k)
  28.             else:
  29.                 dict.__init__(self, *a, **k)
  30.  
  31.         
  32.         def parse(cls, s):
  33.             return (tuple,)((lambda .0: for entry in .0:
  34. entry.strip().split(delim2, 1))(s.split(delim1)))
  35.  
  36.         parse = (None, classmethod)(parse)
  37.         
  38.         def __str__(self):
  39.             return (delim1.join,)((lambda .0: for i in .0:
  40. delim2.join(i))(self.items()))
  41.  
  42.  
  43.     return dictifier
  44.  
  45.  
  46. def dictreverse(mapping):
  47.     return dict((lambda .0: for key, value in .0:
  48. (value, key))(mapping.iteritems()))
  49.  
  50.  
  51. def dictadd(dict_a, dict_b):
  52.     result = dict(dict_a)
  53.     result.update(dict_b)
  54.     return result
  55.  
  56.  
  57. def dictsub(a, b):
  58.     a = a.copy()
  59.     for key in b:
  60.         a.pop(key, None)
  61.     
  62.     return a
  63.  
  64.  
  65. def dictdiff(defaults, user):
  66.     diff = { }
  67.     for k, v in user.iteritems():
  68.         if k not in defaults or v != defaults[k]:
  69.             diff[k] = v
  70.             continue
  71.     
  72.     return diff
  73.  
  74.  
  75. def intdictdiff(start, end):
  76.     keys = set(start.keys()) | set(end.keys())
  77.     out = { }
  78.     for key in keys:
  79.         startval = start.get(key, 0)
  80.         endval = end.get(key, 0)
  81.         outval = endval - startval
  82.         if outval:
  83.             out[key] = outval
  84.             continue
  85.     
  86.     return out
  87.  
  88.  
  89. class DictChain(functional.AttrChain, dict):
  90.     
  91.     def __init__(self, *args, **kwargs):
  92.         dict.__init__(self, *args, **kwargs)
  93.         functional.AttrChain.__init__(self, 'base', self.__getattr2__)
  94.  
  95.     
  96.     def __getattr2__(self, key):
  97.         keys = None if isinstance(key, basestring) else key
  98.         next = self[keys[0]]
  99.         if len(keys) > 1 and isinstance(next, DictChain):
  100.             return dict.__getattribute__(next, '__getattr2__')(keys[1:])
  101.         elif keys:
  102.             
  103.             try:
  104.                 returner = next
  105.             except:
  106.                 return self['generic'][keys[0]]
  107.  
  108.             if isinstance(returner, DictChain):
  109.                 return returner['value']
  110.             else:
  111.                 return returner
  112.         else:
  113.             return self['value']
  114.  
  115.  
  116.  
  117. class Storage(dict):
  118.     
  119.     def __getattr__(self, key, ga = dict.__getattribute__, gi = dict.__getitem__):
  120.         
  121.         try:
  122.             return ga(self, key)
  123.         except AttributeError:
  124.             
  125.             try:
  126.                 return gi(self, key)
  127.             except KeyError:
  128.                 msg = repr(key)
  129.                 if len(self) <= 20:
  130.                     keys = sorted(self.keys())
  131.                     msg += '\n  (%d existing keys: ' % len(keys) + str(keys) + ')'
  132.                 
  133.                 raise AttributeError, msg
  134.             except:
  135.                 None<EXCEPTION MATCH>KeyError
  136.             
  137.  
  138.             None<EXCEPTION MATCH>KeyError
  139.  
  140.  
  141.     
  142.     def __setattr__(self, key, value):
  143.         self[key] = value
  144.  
  145.     
  146.     def copy(self):
  147.         return type(self)(self)
  148.  
  149.  
  150. Storage.__module__ = 'util.primitives'
  151.  
  152. def dictrecurse(newtype):
  153.     
  154.     def recurser(_d, forbidden = (None, ())):
  155.         if not hasattr(_d, 'keys'):
  156.             pformat = pformat
  157.             import pprint
  158.             raise TypeError('what is?\n%s' % pformat(_d))
  159.         
  160.         for k in _d:
  161.             if isinstance(_d[k], dict):
  162.                 _d[k] = recurser(_d[k])
  163.                 continue
  164.             if funcs.isiterable(_d[k]) and not isinstance(_d[k], forbidden + (basestring,)):
  165.                 _d[k] = (list,)((lambda .0: for item in .0:
  166. None if isinstance(item, dict) else item)(_d[k]))
  167.                 continue
  168.         
  169.         if isinstance(newtype, type):
  170.             return None if isinstance(_d, newtype) else newtype(_d)
  171.         else:
  172.             return newtype(_d)
  173.  
  174.     return recurser
  175.  
  176. to_storage = dictrecurse(Storage)
  177.  
  178. def from_storage(d):
  179.     for k, v in d.items():
  180.         if isinstance(v, Storage):
  181.             d[k] = from_storage(v)
  182.             continue
  183.         if isinstance(v, list):
  184.             newlist = [ _[1] if isinstance(e, Storage) else e for e in d[k] ]
  185.             d[k] = newlist
  186.             continue
  187.         []
  188.     
  189.     return None if type(d) is dict else dict(d)
  190.  
  191.  
  192. def lookup_table(*a, **d):
  193.     d = dict(*a, **d)
  194.     d.update(dictreverse(d))
  195.     return to_storage(d)
  196.  
  197.  
  198. class no_case_dict(dict):
  199.     
  200.     def __getitem__(self, attr, get = dict.__getitem__):
  201.         return get(self, attr.lower())
  202.  
  203.     
  204.     def __setitem__(self, attr, val):
  205.         return dict.__setitem__(self, attr.lower(), val)
  206.  
  207.     
  208.     def __delitem__(self, key):
  209.         return dict.__delitem__(self, key.lower())
  210.  
  211.     
  212.     def __contains__(self, attr):
  213.         return dict.__contains__(self, attr.lower())
  214.  
  215.     
  216.     def setdefault(self, attr, default):
  217.         
  218.         try:
  219.             return dict.__getitem__(self, attr.lower())
  220.         except KeyError:
  221.             dict.__setitem__(self, attr.lower(), default)
  222.             return default
  223.  
  224.  
  225.     
  226.     def pop(self, k, x = None):
  227.         return dict.pop(self, k.lower(), x)
  228.  
  229.  
  230.  
  231. def stringify_dict(dict):
  232.     new = { }
  233.     for k, v in dict.items():
  234.         if isinstance(k, basestring):
  235.             new[str(k)] = v
  236.             continue
  237.         new[k] = v
  238.     
  239.     return new
  240.  
  241.  
  242. class odict(dict):
  243.     
  244.     def __init__(self, d = None):
  245.         if d is None:
  246.             d = { }
  247.         
  248.         
  249.         try:
  250.             t = d.items()
  251.             self._keys = [ k for k, _v in t ]
  252.             dict.__init__(self, t)
  253.         except:
  254.             (one, two, three) = itertools.tee(d, 3)
  255.             
  256.             try:
  257.                 self._keys = [ k for k, _v in one ]
  258.             except:
  259.                 self._keys = [ k for k in two ]
  260.  
  261.             [](dict.__init__, self if isinstance(d, dict) else three)
  262.  
  263.  
  264.     
  265.     def __delitem__(self, key):
  266.         dict.__delitem__(self, key)
  267.         self._keys.remove(key)
  268.  
  269.     
  270.     def __setitem__(self, key, item):
  271.         dict.__setitem__(self, key, item)
  272.         if not hasattr(self, '_keys'):
  273.             self._keys = [
  274.                 key]
  275.         
  276.         if key not in self._keys:
  277.             self._keys.append(key)
  278.         
  279.  
  280.     __iter__ = property((lambda self: self._keys.__iter__))
  281.     
  282.     def clear(self):
  283.         dict.clear(self)
  284.         self._keys = []
  285.  
  286.     
  287.     def pop(self, k, defval = sentinel):
  288.         
  289.         try:
  290.             val = dict.pop(self, k)
  291.         except KeyError:
  292.             if defval is sentinel:
  293.                 raise 
  294.             else:
  295.                 return defval
  296.         except:
  297.             defval is sentinel
  298.  
  299.         self._keys.remove(k)
  300.         return val
  301.  
  302.     
  303.     def iteritems(self):
  304.         for i in self._keys:
  305.             
  306.             try:
  307.                 yield (i, self[i])
  308.             continue
  309.             except KeyError:
  310.                 print 'fake keys', self._keys
  311.                 print 'real keys', self.keys()
  312.                 raise 
  313.                 continue
  314.             
  315.  
  316.         
  317.  
  318.     
  319.     def items(self):
  320.         return list(self.iteritems())
  321.  
  322.     
  323.     def keys(self):
  324.         return self._keys
  325.  
  326.     
  327.     def popitem(self):
  328.         if len(self._keys) == 0:
  329.             raise KeyError('dictionary is empty')
  330.         else:
  331.             key = self._keys[-1]
  332.             val = self[key]
  333.             del self[key]
  334.             return (key, val)
  335.  
  336.     
  337.     def setdefault(self, key, failobj = None):
  338.         ret = dict.setdefault(self, key, failobj)
  339.         if key not in self._keys:
  340.             self._keys.append(key)
  341.         
  342.         return ret
  343.  
  344.     
  345.     def update(self, d):
  346.         
  347.         try:
  348.             for key in d.keys():
  349.                 if not self.has_key(key):
  350.                     self._keys.append(key)
  351.                     continue
  352.         except AttributeError:
  353.             for k, v in d:
  354.                 self[k] = v
  355.             
  356.             return None
  357.  
  358.         dict.update(self, d)
  359.  
  360.     
  361.     def values(self):
  362.         for i in self._keys:
  363.             yield self[i]
  364.         
  365.  
  366.     
  367.     def move(self, key, index):
  368.         
  369.         try:
  370.             cur = self._keys.index(key)
  371.         except ValueError:
  372.             raise KeyError(key)
  373.  
  374.         self._keys.insert(index, key)
  375.         if cur >= index:
  376.             cur = cur + 1
  377.         
  378.         del self._keys[cur]
  379.  
  380.     
  381.     def index(self, key):
  382.         if not self.has_key(key):
  383.             raise KeyError(key)
  384.         
  385.         return self._keys.index(key)
  386.  
  387.  
  388.  
  389. class LazySortedDict(odict):
  390.     
  391.     def _get_keys(self):
  392.         
  393.         try:
  394.             self._real_keys = sorted(self._real_keys)
  395.         except AttributeError:
  396.             self._real_keys = []
  397.  
  398.         return self._real_keys
  399.  
  400.     
  401.     def _set_keys(self, keys):
  402.         self._real_keys = sorted(keys)
  403.  
  404.     
  405.     def copy(self):
  406.         return type(self)(self)
  407.  
  408.     _keys = property(_get_keys, _set_keys)
  409.  
  410.  
  411. class ostorage(odict, Storage):
  412.     
  413.     def __getattr__(self, attr):
  414.         if attr == '_keys':
  415.             return odict.__getattr__(self, '_keys')
  416.         else:
  417.             return Storage.__getattr__(self, attr)
  418.  
  419.     
  420.     def __setattr__(self, attr, val):
  421.         if attr == '_keys':
  422.             return odict.__setattr__(self, attr, val)
  423.         else:
  424.             return Storage.__setattr__(self, attr, val)
  425.  
  426.  
  427.  
  428. def groupify(seq, keys = None, whitelist = True, mapclass = odict):
  429.     retval = [
  430.         mapclass()]
  431.     idx = 0
  432.     for k, v in seq:
  433.         if keys and whitelist ^ (k in keys):
  434.             continue
  435.         
  436.         if k in retval[idx]:
  437.             retval.append(mapclass())
  438.             idx += 1
  439.         
  440.         retval[idx][k] = v
  441.     
  442.     if not retval[0]:
  443.         return []
  444.     
  445.     return retval
  446.  
  447.  
  448. class FilterDict(dict):
  449.     
  450.     def __init__(self, filterfunc, d = None, **kw):
  451.         if d is None:
  452.             d = { }
  453.         
  454.         dict.__init__(self)
  455.         d.update(kw)
  456.         dict.__setattr__(self, 'ff', filterfunc)
  457.         for k, v in d.iteritems():
  458.             self.__setitem__(k, v)
  459.         
  460.  
  461.     
  462.     def __getitem__(self, key):
  463.         return dict.__getitem__(self, self.ff(key))
  464.  
  465.     
  466.     def __delitem__(self, key):
  467.         return dict.__delitem__(self, self.ff(key))
  468.  
  469.     
  470.     def __contains__(self, key):
  471.         return dict.__contains__(self, self.ff(key))
  472.  
  473.     
  474.     def __setitem__(self, key, newval):
  475.         return dict.__setitem__(self, self.ff(key), newval)
  476.  
  477.  
  478.  
  479. class LowerDict(FilterDict):
  480.     
  481.     def __init__(self, *a, **k):
  482.         
  483.         def filterfunc(x):
  484.             
  485.             try:
  486.                 x = x.lower()
  487.             except:
  488.                 pass
  489.  
  490.             return x
  491.  
  492.         FilterDict.__init__(self, filterfunc, *a, **k)
  493.  
  494.  
  495. recurse_lower = dictrecurse(LowerDict)
  496.  
  497. class LowerStorage(LowerDict, Storage):
  498.     
  499.     def __init__(self, *a, **k):
  500.         Storage.__init__(self)
  501.         LowerDict.__init__(self, *a, **k)
  502.  
  503.  
  504. recurse_lower_storage = dictrecurse(LowerStorage)
  505.  
  506. def odict_from_dictlist(seq):
  507.     od = odict()
  508.     for subdict in seq:
  509.         key = subdict.keys()[0]
  510.         od[key] = subdict[key]
  511.     
  512.     return od
  513.  
  514. if __name__ == '__main__':
  515.     import doctest
  516.     doctest.testmod(verbose = True)
  517.  
  518.