home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / util / primitives / structures.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  12.6 KB  |  391 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import mapping
  5. import struct
  6.  
  7. class enum(list):
  8.     
  9.     def __init__(self, *args):
  10.         list.__init__(self, args)
  11.  
  12.     
  13.     def __getattr__(self, elem):
  14.         return self.index(elem)
  15.  
  16.     
  17.     def __getitem__(self, i):
  18.         if isinstance(i, basestring):
  19.             return self.__getattr__(i)
  20.         else:
  21.             return list.__getitem__(self, i)
  22.  
  23.  
  24.  
  25. def new_packable(fmt, byteorder = '!', invars = None):
  26.     if not invars:
  27.         pass
  28.     invars = []
  29.     slots = fmt[::2]
  30.     fmtstring = byteorder + ''.join(fmt[1::2])
  31.     
  32.     class packable(None, 'packable', (object,)):
  33.         __slots__ = slots
  34.         _fmt = fmtstring
  35.         invariants = invars
  36.         
  37.         def unpack(cls, data):
  38.             o = cls(*struct.unpack(cls._fmt, data))
  39.             return o
  40.  
  41.         unpack = classmethod(unpack)
  42.         
  43.         def __init__(self, *a, **kw):
  44.             i = -1
  45.             for i, d in enumerate(a):
  46.                 setattr(self, self.__slots__[i], d)
  47.             
  48.             for field in self.__slots__[i + 1:]:
  49.                 setattr(self, field, 0)
  50.             
  51.             for k in kw:
  52.                 setattr(self, k, kw[k])
  53.             
  54.  
  55.         
  56.         def pack(self):
  57.             return struct.pack((self._fmt,), *(lambda .0: for field in .0:
  58. getattr(self, field))(self.__slots__))
  59.  
  60.         
  61.         def __iter__(self):
  62.             return (lambda .0: for s in .0:
  63. (s, getattr(self, s)))(self.__slots__)
  64.  
  65.         
  66.         def __len__(self):
  67.             return struct.calcsize(self._fmt)
  68.  
  69.         __str__ = pack
  70.         
  71.         def __eq__(self, other):
  72.             o = ()
  73.             for slot in self.__slots__:
  74.                 sval = getattr(self, slot)
  75.                 oval = getattr(other, slot, o)
  76.                 if oval is o:
  77.                     return False
  78.                 
  79.                 if oval != sval:
  80.                     return False
  81.                     continue
  82.             
  83.             return True
  84.  
  85.         
  86.         def __ne__(self, other):
  87.             return not self.__eq__(other)
  88.  
  89.         
  90.         def copy(self):
  91.             return self.unpack(self.pack())
  92.  
  93.  
  94.     return packable
  95.  
  96.  
  97. def unpack_named(format, *args):
  98.     data = args[-1]
  99.     rest = None
  100.     if 'R' in format:
  101.         if format.find('R') != len(format) - 1:
  102.             raise AssertionError('R character in format string to unpack_named can only appear at the end')
  103.         else:
  104.             format = format[:-1]
  105.             sz = struct.calcsize(format)
  106.             rest = data[sz:]
  107.             data = data[:sz]
  108.     
  109.     tup = struct.unpack(format, data)
  110.     magic_hash = { }
  111.     for i in xrange(len(tup)):
  112.         magic_hash[args[i]] = tup[i]
  113.     
  114.     if rest:
  115.         magic_hash[args[i + 1]] = rest
  116.     
  117.     return mapping.to_storage(magic_hash)
  118.  
  119.  
  120. def remove_from_list(my_list, remove_these):
  121.     my_list = my_list[:]
  122.     remove_list = _[1]
  123.     for e in remove_list:
  124.         my_list.remove(e)
  125.     
  126.     return my_list
  127.  
  128.  
  129. class oset(set):
  130.     
  131.     def __init__(self, iterable = []):
  132.         self.data = []
  133.         self.update(iterable, init = True)
  134.  
  135.     
  136.     def add(self, val):
  137.         if val not in self.data:
  138.             self.data.append(val)
  139.             set.add(self, val)
  140.         
  141.  
  142.     
  143.     def __getitem__(self, n):
  144.         return self.data[n]
  145.  
  146.     
  147.     def __iter__(self):
  148.         return iter(self.data)
  149.  
  150.     
  151.     def clear(self):
  152.         del self.data[:]
  153.         set.clear(self)
  154.  
  155.     
  156.     def pop(self):
  157.         ret = set.pop(self)
  158.         self.data.remove(ret)
  159.         return ret
  160.  
  161.     
  162.     def remove(self, item):
  163.         self.data.remove(item)
  164.         set.remove(self, item)
  165.  
  166.     
  167.     def discard(self, item):
  168.         
  169.         try:
  170.             self.remove(item)
  171.         except ValueError:
  172.             pass
  173.         except KeyError:
  174.             pass
  175.  
  176.  
  177.     
  178.     def union(self, other):
  179.         if not isinstance(other, oset):
  180.             other = oset(other)
  181.         
  182.         return self | other
  183.  
  184.     
  185.     def __or__(self, other):
  186.         if not isinstance(other, set):
  187.             raise ValueError, 'other must be a set'
  188.         
  189.         ret = oset(self)
  190.         ret.update(other)
  191.         return ret
  192.  
  193.     
  194.     def intersection(self, other):
  195.         if not isinstance(other, oset):
  196.             other = oset(other)
  197.         
  198.         return self & other
  199.  
  200.     
  201.     def __and__(self, other):
  202.         if not isinstance(other, set):
  203.             raise ValueError, 'other must be a set'
  204.         
  205.         a = oset(self)
  206.         b = other
  207.         return a - a - b
  208.  
  209.     
  210.     def difference(self, other):
  211.         other = oset(other)
  212.         return self - other
  213.  
  214.     
  215.     def __sub__(self, other):
  216.         if not isinstance(other, set):
  217.             raise ValueError, 'other must be a set'
  218.         
  219.         first = oset(self)
  220.         first -= other
  221.         return first
  222.  
  223.     
  224.     def symmetric_difference(self, other):
  225.         if not isinstance(other, oset):
  226.             other = oset(other)
  227.         
  228.         return self ^ other
  229.  
  230.     
  231.     def __xor__(self, other):
  232.         if not isinstance(other, set):
  233.             raise ValueError, 'other must be a set'
  234.         
  235.         return (self | other) - (self & other)
  236.  
  237.     
  238.     def copy(self):
  239.         return oset(self)
  240.  
  241.     
  242.     def update(self, other, init = False):
  243.         if not isinstance(other, oset) and not init:
  244.             other = oset(other)
  245.         
  246.         self.__ior__(other, init = init)
  247.  
  248.     
  249.     def __ior__(self, other, init = False):
  250.         if not isinstance(other, set) and not init:
  251.             raise ValueError, 'other must be a set'
  252.         
  253.         for i in other:
  254.             self.add(i)
  255.         
  256.         return self
  257.  
  258.     
  259.     def intersection_update(self, other):
  260.         if not isinstance(other, oset):
  261.             other = oset(other)
  262.         
  263.         self &= other
  264.  
  265.     
  266.     def __iand__(self, other):
  267.         if not isinstance(other, set):
  268.             raise ValueError, 'other must be a set'
  269.         
  270.         self -= self & other
  271.  
  272.     
  273.     def difference_update(self, other):
  274.         if not isinstance(other, oset):
  275.             other = oset(other)
  276.         
  277.         self -= other
  278.  
  279.     
  280.     def __isub__(self, other):
  281.         if not isinstance(other, set):
  282.             raise ValueError, 'other must be a set'
  283.         
  284.         for item in other:
  285.             self.discard(item)
  286.         
  287.         return self
  288.  
  289.     
  290.     def symmetric_difference_update(self, other):
  291.         if not isinstance(other, oset):
  292.             other = oset(other)
  293.         
  294.         self ^= other
  295.  
  296.     
  297.     def __ixor__(self, other):
  298.         if not isinstance(other, set):
  299.             raise ValueError, 'other must be a set'
  300.         
  301.         b = oset(other)
  302.         b -= self
  303.         self -= other
  304.         self |= b
  305.         return self
  306.  
  307.  
  308.  
  309. class roset(oset):
  310.     
  311.     def add(self, val):
  312.         if val in self:
  313.             self.data.remove(val)
  314.             self.data.append(val)
  315.         else:
  316.             oset.add(self, val)
  317.  
  318.     
  319.     def insert(self, idx, item):
  320.         if item in self:
  321.             self.data.remove(item)
  322.         
  323.         self.data.insert(idx, item)
  324.         set.add(self, item)
  325.  
  326.  
  327.  
  328. class EmptyQueue(Exception):
  329.     pass
  330.  
  331.  
  332. class PriorityQueue(object):
  333.     default_priority = 5
  334.     
  335.     def __init__(self, *args):
  336.         self.q = [ (self.default_priority, arg) for arg in args ]
  337.         
  338.         self.key = lambda a: a[0]
  339.         self.q.sort(key = self.key)
  340.  
  341.     
  342.     def __len__(self):
  343.         return len(self.q)
  344.  
  345.     
  346.     def count(self, x):
  347.         return self.q.count(x)
  348.  
  349.     
  350.     def peek(self):
  351.         if not self.q:
  352.             raise EmptyQueue
  353.         
  354.         (__, item) = self.q[0]
  355.         return item
  356.  
  357.     
  358.     def __iadd__(self, elemtuple):
  359.         if isinstance(elemtuple, (tuple, list)):
  360.             if len(elemtuple) != 2:
  361.                 raise TypeError('add to the PriorityQueue like += (item, priority) or just += item')
  362.             
  363.             self.append(*elemtuple)
  364.         else:
  365.             self.append(elemtuple)
  366.         return self
  367.  
  368.     
  369.     def __nonzero__(self):
  370.         return self.q.__len__()
  371.  
  372.     
  373.     def append(self, item, priority = default_priority):
  374.         self.q.append((priority, item))
  375.         self.q.sort(key = self.key)
  376.  
  377.     
  378.     def next(self):
  379.         (__, item) = self.q.pop(0)
  380.         return item
  381.  
  382.     
  383.     def __repr__(self):
  384.         return '<PriorityQueue %r>' % self.q
  385.  
  386.  
  387. if __name__ == '__main__':
  388.     import doctest
  389.     doctest.testmod(verbose = True)
  390.  
  391.