home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_335 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  8.3 KB  |  411 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import types
  5. from copy_reg import dispatch_table
  6.  
  7. class Error(Exception):
  8.     pass
  9.  
  10. error = Error
  11.  
  12. try:
  13.     from org.python.core import PyStringMap
  14. except ImportError:
  15.     PyStringMap = None
  16.  
  17. __all__ = [
  18.     'Error',
  19.     'copy',
  20.     'deepcopy']
  21.  
  22. def copy(x):
  23.     cls = type(x)
  24.     copier = _copy_dispatch.get(cls)
  25.     if copier:
  26.         return copier(x)
  27.     copier = getattr(cls, '__copy__', None)
  28.     if copier:
  29.         return copier(x)
  30.     reductor = dispatch_table.get(cls)
  31.     if reductor:
  32.         rv = reductor(x)
  33.     else:
  34.         reductor = getattr(x, '__reduce_ex__', None)
  35.         if reductor:
  36.             rv = reductor(2)
  37.         else:
  38.             reductor = getattr(x, '__reduce__', None)
  39.             if reductor:
  40.                 rv = reductor()
  41.             else:
  42.                 raise Error('un(shallow)copyable object of type %s' % cls)
  43.             return reductor(x, rv, 0)
  44.  
  45. _copy_dispatch = d = { }
  46.  
  47. def _copy_immutable(x):
  48.     return x
  49.  
  50. for t in (type(None), int, long, float, bool, str, tuple, frozenset, type, xrange, types.ClassType, types.BuiltinFunctionType, type(Ellipsis), types.FunctionType):
  51.     d[t] = _copy_immutable
  52.  
  53. for name in ('ComplexType', 'UnicodeType', 'CodeType'):
  54.     t = getattr(types, name, None)
  55.     if t is not None:
  56.         d[t] = _copy_immutable
  57.         continue
  58.  
  59.  
  60. def _copy_with_constructor(x):
  61.     return type(x)(x)
  62.  
  63. for t in (list, dict, set):
  64.     d[t] = _copy_with_constructor
  65.  
  66.  
  67. def _copy_with_copy_method(x):
  68.     return x.copy()
  69.  
  70. if PyStringMap is not None:
  71.     d[PyStringMap] = _copy_with_copy_method
  72.  
  73.  
  74. def _copy_inst(x):
  75.     if hasattr(x, '__copy__'):
  76.         return x.__copy__()
  77.     if hasattr(x, '__getinitargs__'):
  78.         args = x.__getinitargs__()
  79.         y = x.__class__(*args)
  80.     else:
  81.         y = _EmptyClass()
  82.         y.__class__ = x.__class__
  83.     if hasattr(x, '__getstate__'):
  84.         state = x.__getstate__()
  85.     else:
  86.         state = x.__dict__
  87.     if hasattr(y, '__setstate__'):
  88.         y.__setstate__(state)
  89.     else:
  90.         y.__dict__.update(state)
  91.     return y
  92.  
  93. d[types.InstanceType] = _copy_inst
  94. del d
  95.  
  96. def deepcopy(x, memo = None, _nil = []):
  97.     if memo is None:
  98.         memo = { }
  99.     
  100.     d = id(x)
  101.     y = memo.get(d, _nil)
  102.     if y is not _nil:
  103.         return y
  104.     cls = type(x)
  105.     copier = _deepcopy_dispatch.get(cls)
  106.     if copier:
  107.         y = copier(x, memo)
  108.     else:
  109.         
  110.         try:
  111.             issc = issubclass(cls, type)
  112.         except TypeError:
  113.             issc = 0
  114.  
  115.         if issc:
  116.             y = _deepcopy_atomic(x, memo)
  117.         else:
  118.             copier = getattr(x, '__deepcopy__', None)
  119.             if copier:
  120.                 y = copier(memo)
  121.             else:
  122.                 reductor = dispatch_table.get(cls)
  123.                 if reductor:
  124.                     rv = reductor(x)
  125.                 else:
  126.                     reductor = getattr(x, '__reduce_ex__', None)
  127.                     if reductor:
  128.                         rv = reductor(2)
  129.                     else:
  130.                         reductor = getattr(x, '__reduce__', None)
  131.                         if reductor:
  132.                             rv = reductor()
  133.                         else:
  134.                             raise Error('un(deep)copyable object of type %s' % cls)
  135.                         y = reductor(x, rv, 1, memo)
  136.                         memo[d] = y
  137.                         _keep_alive(x, memo)
  138.                         return y
  139.  
  140. _deepcopy_dispatch = d = { }
  141.  
  142. def _deepcopy_atomic(x, memo):
  143.     return x
  144.  
  145. d[type(None)] = _deepcopy_atomic
  146. d[type(Ellipsis)] = _deepcopy_atomic
  147. d[int] = _deepcopy_atomic
  148. d[long] = _deepcopy_atomic
  149. d[float] = _deepcopy_atomic
  150. d[bool] = _deepcopy_atomic
  151.  
  152. try:
  153.     d[complex] = _deepcopy_atomic
  154. except NameError:
  155.     pass
  156.  
  157. d[str] = _deepcopy_atomic
  158.  
  159. try:
  160.     d[unicode] = _deepcopy_atomic
  161. except NameError:
  162.     pass
  163.  
  164.  
  165. try:
  166.     d[types.CodeType] = _deepcopy_atomic
  167. except AttributeError:
  168.     pass
  169.  
  170. d[type] = _deepcopy_atomic
  171. d[xrange] = _deepcopy_atomic
  172. d[types.ClassType] = _deepcopy_atomic
  173. d[types.BuiltinFunctionType] = _deepcopy_atomic
  174. d[types.FunctionType] = _deepcopy_atomic
  175.  
  176. def _deepcopy_list(x, memo):
  177.     y = []
  178.     memo[id(x)] = y
  179.     for a in x:
  180.         y.append(deepcopy(a, memo))
  181.     
  182.     return y
  183.  
  184. d[list] = _deepcopy_list
  185.  
  186. def _deepcopy_tuple(x, memo):
  187.     y = []
  188.     for a in x:
  189.         y.append(deepcopy(a, memo))
  190.     
  191.     d = id(x)
  192.     
  193.     try:
  194.         return memo[d]
  195.     except KeyError:
  196.         pass
  197.  
  198.     for i in range(len(x)):
  199.         if x[i] is not y[i]:
  200.             y = tuple(y)
  201.             break
  202.             continue
  203.     else:
  204.         y = x
  205.     memo[d] = y
  206.     return y
  207.  
  208. d[tuple] = _deepcopy_tuple
  209.  
  210. def _deepcopy_dict(x, memo):
  211.     y = { }
  212.     memo[id(x)] = y
  213.     for key, value in x.iteritems():
  214.         y[deepcopy(key, memo)] = deepcopy(value, memo)
  215.     
  216.     return y
  217.  
  218. d[dict] = _deepcopy_dict
  219. if PyStringMap is not None:
  220.     d[PyStringMap] = _deepcopy_dict
  221.  
  222.  
  223. def _keep_alive(x, memo):
  224.     
  225.     try:
  226.         memo[id(memo)].append(x)
  227.     except KeyError:
  228.         memo[id(memo)] = [
  229.             x]
  230.  
  231.  
  232.  
  233. def _deepcopy_inst(x, memo):
  234.     if hasattr(x, '__deepcopy__'):
  235.         return x.__deepcopy__(memo)
  236.     if hasattr(x, '__getinitargs__'):
  237.         args = x.__getinitargs__()
  238.         args = deepcopy(args, memo)
  239.         y = x.__class__(*args)
  240.     else:
  241.         y = _EmptyClass()
  242.         y.__class__ = x.__class__
  243.     memo[id(x)] = y
  244.     if hasattr(x, '__getstate__'):
  245.         state = x.__getstate__()
  246.     else:
  247.         state = x.__dict__
  248.     state = deepcopy(state, memo)
  249.     if hasattr(y, '__setstate__'):
  250.         y.__setstate__(state)
  251.     else:
  252.         y.__dict__.update(state)
  253.     return y
  254.  
  255. d[types.InstanceType] = _deepcopy_inst
  256.  
  257. def _reconstruct(x, info, deep, memo = None):
  258.     if isinstance(info, str):
  259.         return x
  260.     if memo is None:
  261.         memo = { }
  262.     
  263.     n = len(info)
  264.     (callable, args) = info[:2]
  265.     if n > 2:
  266.         state = info[2]
  267.     else:
  268.         state = { }
  269.     if n > 3:
  270.         listiter = info[3]
  271.     else:
  272.         listiter = None
  273.     if n > 4:
  274.         dictiter = info[4]
  275.     else:
  276.         dictiter = None
  277.     if deep:
  278.         args = deepcopy(args, memo)
  279.     
  280.     y = callable(*args)
  281.     memo[id(x)] = y
  282.     if listiter is not None:
  283.         for item in listiter:
  284.             if deep:
  285.                 item = deepcopy(item, memo)
  286.             
  287.             y.append(item)
  288.         
  289.     
  290.     if dictiter is not None:
  291.         for key, value in dictiter:
  292.             if deep:
  293.                 key = deepcopy(key, memo)
  294.                 value = deepcopy(value, memo)
  295.             
  296.             y[key] = value
  297.         
  298.     
  299.     if state:
  300.         if deep:
  301.             state = deepcopy(state, memo)
  302.         
  303.         if hasattr(y, '__setstate__'):
  304.             y.__setstate__(state)
  305.         elif isinstance(state, tuple) and len(state) == 2:
  306.             (state, slotstate) = state
  307.         else:
  308.             slotstate = None
  309.         if state is not None:
  310.             y.__dict__.update(state)
  311.         
  312.         if slotstate is not None:
  313.             for key, value in slotstate.iteritems():
  314.                 setattr(y, key, value)
  315.             
  316.         
  317.     
  318.     return y
  319.  
  320. del d
  321. del types
  322.  
  323. class _EmptyClass:
  324.     pass
  325.  
  326.  
  327. def _test():
  328.     l = [
  329.         None,
  330.         1,
  331.         0x2L,
  332.         3.14,
  333.         'xyzzy',
  334.         (1, 0x2L),
  335.         [
  336.             3.14,
  337.             'abc'],
  338.         {
  339.             'abc': 'ABC' },
  340.         (),
  341.         [],
  342.         { }]
  343.     l1 = copy(l)
  344.     print l1 == l
  345.     l1 = map(copy, l)
  346.     print l1 == l
  347.     l1 = deepcopy(l)
  348.     print l1 == l
  349.     
  350.     class C:
  351.         
  352.         def __init__(self, arg = None):
  353.             self.a = 1
  354.             self.arg = arg
  355.             if __name__ == '__main__':
  356.                 import sys
  357.                 file = sys.argv[0]
  358.             else:
  359.                 file = __file__
  360.             self.fp = open(file)
  361.             self.fp.close()
  362.  
  363.         
  364.         def __getstate__(self):
  365.             return {
  366.                 'a': self.a,
  367.                 'arg': self.arg }
  368.  
  369.         
  370.         def __setstate__(self, state):
  371.             for key, value in state.iteritems():
  372.                 setattr(self, key, value)
  373.             
  374.  
  375.         
  376.         def __deepcopy__(self, memo = None):
  377.             new = self.__class__(deepcopy(self.arg, memo))
  378.             new.a = self.a
  379.             return new
  380.  
  381.  
  382.     c = C('argument sketch')
  383.     l.append(c)
  384.     l2 = copy(l)
  385.     print l == l2
  386.     print l
  387.     print l2
  388.     l2 = deepcopy(l)
  389.     print l == l2
  390.     print l
  391.     print l2
  392.     l.append({
  393.         l[1]: l,
  394.         'xyz': l[2] })
  395.     l3 = copy(l)
  396.     import repr
  397.     print map(repr.repr, l)
  398.     print map(repr.repr, l1)
  399.     print map(repr.repr, l2)
  400.     print map(repr.repr, l3)
  401.     l3 = deepcopy(l)
  402.     import repr
  403.     print map(repr.repr, l)
  404.     print map(repr.repr, l1)
  405.     print map(repr.repr, l2)
  406.     print map(repr.repr, l3)
  407.  
  408. if __name__ == '__main__':
  409.     _test()
  410.  
  411.