home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / GestionFichiers / metamorphose / metamorphose2_0.8.2_setup.exe / metamorphose2.exe / UserDict.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2011-01-12  |  8KB  |  292 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4.  
  5. class UserDict:
  6.     
  7.     def __init__(self, dict = None, **kwargs):
  8.         self.data = { }
  9.         if dict is not None:
  10.             self.update(dict)
  11.         
  12.         if len(kwargs):
  13.             self.update(kwargs)
  14.         
  15.  
  16.     
  17.     def __repr__(self):
  18.         return repr(self.data)
  19.  
  20.     
  21.     def __cmp__(self, dict):
  22.         if isinstance(dict, UserDict):
  23.             return cmp(self.data, dict.data)
  24.         return cmp(self.data, dict)
  25.  
  26.     
  27.     def __len__(self):
  28.         return len(self.data)
  29.  
  30.     
  31.     def __getitem__(self, key):
  32.         if key in self.data:
  33.             return self.data[key]
  34.         if hasattr(self.__class__, '__missing__'):
  35.             return self.__class__.__missing__(self, key)
  36.         raise KeyError(key)
  37.  
  38.     
  39.     def __setitem__(self, key, item):
  40.         self.data[key] = item
  41.  
  42.     
  43.     def __delitem__(self, key):
  44.         del self.data[key]
  45.  
  46.     
  47.     def clear(self):
  48.         self.data.clear()
  49.  
  50.     
  51.     def copy(self):
  52.         if self.__class__ is UserDict:
  53.             return UserDict(self.data.copy())
  54.         import copy as copy
  55.         data = self.data
  56.         
  57.         try:
  58.             self.data = { }
  59.             c = copy.copy(self)
  60.         finally:
  61.             self.data = data
  62.  
  63.         c.update(self)
  64.         return c
  65.  
  66.     
  67.     def keys(self):
  68.         return self.data.keys()
  69.  
  70.     
  71.     def items(self):
  72.         return self.data.items()
  73.  
  74.     
  75.     def iteritems(self):
  76.         return self.data.iteritems()
  77.  
  78.     
  79.     def iterkeys(self):
  80.         return self.data.iterkeys()
  81.  
  82.     
  83.     def itervalues(self):
  84.         return self.data.itervalues()
  85.  
  86.     
  87.     def values(self):
  88.         return self.data.values()
  89.  
  90.     
  91.     def has_key(self, key):
  92.         return key in self.data
  93.  
  94.     
  95.     def update(self, dict = None, **kwargs):
  96.         if dict is None:
  97.             pass
  98.         elif isinstance(dict, UserDict):
  99.             self.data.update(dict.data)
  100.         elif isinstance(dict, type({ })) or not hasattr(dict, 'items'):
  101.             self.data.update(dict)
  102.         else:
  103.             for k, v in dict.items():
  104.                 self[k] = v
  105.             
  106.         if len(kwargs):
  107.             self.data.update(kwargs)
  108.         
  109.  
  110.     
  111.     def get(self, key, failobj = None):
  112.         if key not in self:
  113.             return failobj
  114.         return self[key]
  115.  
  116.     
  117.     def setdefault(self, key, failobj = None):
  118.         if key not in self:
  119.             self[key] = failobj
  120.         
  121.         return self[key]
  122.  
  123.     
  124.     def pop(self, key, *args):
  125.         return self.data.pop(key, *args)
  126.  
  127.     
  128.     def popitem(self):
  129.         return self.data.popitem()
  130.  
  131.     
  132.     def __contains__(self, key):
  133.         return key in self.data
  134.  
  135.     
  136.     def fromkeys(cls, iterable, value = None):
  137.         d = cls()
  138.         for key in iterable:
  139.             d[key] = value
  140.         
  141.         return d
  142.  
  143.     fromkeys = classmethod(fromkeys)
  144.  
  145.  
  146. class IterableUserDict(UserDict):
  147.     
  148.     def __iter__(self):
  149.         return iter(self.data)
  150.  
  151.  
  152. import _abcoll
  153. _abcoll.MutableMapping.register(IterableUserDict)
  154.  
  155. class DictMixin:
  156.     
  157.     def __iter__(self):
  158.         for k in self.keys():
  159.             yield k
  160.         
  161.  
  162.     
  163.     def has_key(self, key):
  164.         
  165.         try:
  166.             value = self[key]
  167.         except KeyError:
  168.             return False
  169.  
  170.         return True
  171.  
  172.     
  173.     def __contains__(self, key):
  174.         return self.has_key(key)
  175.  
  176.     
  177.     def iteritems(self):
  178.         for k in self:
  179.             yield (k, self[k])
  180.         
  181.  
  182.     
  183.     def iterkeys(self):
  184.         return self.__iter__()
  185.  
  186.     
  187.     def itervalues(self):
  188.         for _, v in self.iteritems():
  189.             yield v
  190.         
  191.  
  192.     
  193.     def values(self):
  194.         return [ v for _, v in self.iteritems() ]
  195.  
  196.     
  197.     def items(self):
  198.         return list(self.iteritems())
  199.  
  200.     
  201.     def clear(self):
  202.         for key in self.keys():
  203.             del self[key]
  204.         
  205.  
  206.     
  207.     def setdefault(self, key, default = None):
  208.         
  209.         try:
  210.             return self[key]
  211.         except KeyError:
  212.             self[key] = default
  213.  
  214.         return default
  215.  
  216.     
  217.     def pop(self, key, *args):
  218.         if len(args) > 1:
  219.             raise TypeError, 'pop expected at most 2 arguments, got ' + repr(1 + len(args))
  220.         len(args) > 1
  221.         
  222.         try:
  223.             value = self[key]
  224.         except KeyError:
  225.             if args:
  226.                 return args[0]
  227.             raise 
  228.         except:
  229.             args
  230.  
  231.         del self[key]
  232.         return value
  233.  
  234.     
  235.     def popitem(self):
  236.         
  237.         try:
  238.             (k, v) = self.iteritems().next()
  239.         except StopIteration:
  240.             raise KeyError, 'container is empty'
  241.  
  242.         del self[k]
  243.         return (k, v)
  244.  
  245.     
  246.     def update(self, other = None, **kwargs):
  247.         if other is None:
  248.             pass
  249.         elif hasattr(other, 'iteritems'):
  250.             for k, v in other.iteritems():
  251.                 self[k] = v
  252.             
  253.         elif hasattr(other, 'keys'):
  254.             for k in other.keys():
  255.                 self[k] = other[k]
  256.             
  257.         else:
  258.             for k, v in other:
  259.                 self[k] = v
  260.             
  261.         if kwargs:
  262.             self.update(kwargs)
  263.         
  264.  
  265.     
  266.     def get(self, key, default = None):
  267.         
  268.         try:
  269.             return self[key]
  270.         except KeyError:
  271.             return default
  272.  
  273.  
  274.     
  275.     def __repr__(self):
  276.         return repr(dict(self.iteritems()))
  277.  
  278.     
  279.     def __cmp__(self, other):
  280.         if other is None:
  281.             return 1
  282.         if isinstance(other, DictMixin):
  283.             other = dict(other.iteritems())
  284.         
  285.         return cmp(dict(self.iteritems()), other)
  286.  
  287.     
  288.     def __len__(self):
  289.         return len(self.keys())
  290.  
  291.  
  292.