home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1733 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  8.4 KB  |  304 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import time
  5. import os
  6. import threading
  7. import sys
  8. import types
  9. import imp
  10. import inspect
  11. import traceback
  12. import atexit
  13. import weakref
  14.  
  15. def _get_compiled_ext():
  16.     for ext, mode, typ in imp.get_suffixes():
  17.         if typ == imp.PY_COMPILED:
  18.             return ext
  19.     
  20.  
  21. PY_COMPILED_EXT = _get_compiled_ext()
  22.  
  23. class ModuleReloader(object):
  24.     failed = { }
  25.     modules = { }
  26.     skip_modules = { }
  27.     check_all = True
  28.     old_objects = { }
  29.     
  30.     def check(self, check_all = False):
  31.         if check_all or self.check_all:
  32.             modules = sys.modules.keys()
  33.         else:
  34.             modules = self.modules.keys()
  35.         for modname in modules:
  36.             m = sys.modules.get(modname, None)
  37.             if modname in self.skip_modules:
  38.                 continue
  39.             
  40.             if not hasattr(m, '__file__'):
  41.                 continue
  42.             
  43.             if m.__name__ == '__main__':
  44.                 continue
  45.             
  46.             filename = m.__file__
  47.             dirname = os.path.dirname(filename)
  48.             (path, ext) = os.path.splitext(filename)
  49.             if ext.lower() == '.py':
  50.                 ext = PY_COMPILED_EXT
  51.                 filename = os.path.join(dirname, path + PY_COMPILED_EXT)
  52.             
  53.             if ext != PY_COMPILED_EXT:
  54.                 continue
  55.             
  56.             
  57.             try:
  58.                 pymtime = os.stat(filename[:-1]).st_mtime
  59.                 if pymtime <= os.stat(filename).st_mtime:
  60.                     continue
  61.                 
  62.                 if self.failed.get(filename[:-1], None) == pymtime:
  63.                     continue
  64.             except OSError:
  65.                 continue
  66.  
  67.             
  68.             try:
  69.                 superreload(m, reload, self.old_objects)
  70.                 if filename[:-1] in self.failed:
  71.                     del self.failed[filename[:-1]]
  72.             continue
  73.             print >>sys.stderr, '[autoreload of %s failed: %s]' % (modname, traceback.format_exc(1))
  74.             self.failed[filename[:-1]] = pymtime
  75.             continue
  76.  
  77.         
  78.  
  79.  
  80.  
  81. def update_function(old, new):
  82.     for name in [
  83.         'func_code',
  84.         'func_defaults',
  85.         'func_doc',
  86.         'func_closure',
  87.         'func_globals',
  88.         'func_dict']:
  89.         
  90.         try:
  91.             setattr(old, name, getattr(new, name))
  92.         continue
  93.         except (AttributeError, TypeError):
  94.             continue
  95.         
  96.  
  97.     
  98.  
  99.  
  100. def update_class(old, new):
  101.     for key in old.__dict__.keys():
  102.         old_obj = getattr(old, key)
  103.         
  104.         try:
  105.             new_obj = getattr(new, key)
  106.         except AttributeError:
  107.             
  108.             try:
  109.                 delattr(old, key)
  110.             continue
  111.             except (AttributeError, TypeError):
  112.                 continue
  113.             
  114.  
  115.         except:
  116.             None<EXCEPTION MATCH>(AttributeError, TypeError)
  117.  
  118.         if update_generic(old_obj, new_obj):
  119.             continue
  120.         
  121.         
  122.         try:
  123.             setattr(old, key, getattr(new, key))
  124.         continue
  125.         except (AttributeError, TypeError):
  126.             continue
  127.         
  128.  
  129.     
  130.  
  131.  
  132. def update_property(old, new):
  133.     update_generic(old.fdel, new.fdel)
  134.     update_generic(old.fget, new.fget)
  135.     update_generic(old.fset, new.fset)
  136.  
  137.  
  138. def isinstance2(a, b, typ):
  139.     if isinstance(a, typ):
  140.         pass
  141.     return isinstance(b, typ)
  142.  
  143. UPDATE_RULES = [
  144.     ((lambda a, b: isinstance2(a, b, types.ClassType)), update_class),
  145.     ((lambda a, b: isinstance2(a, b, types.TypeType)), update_class),
  146.     ((lambda a, b: isinstance2(a, b, types.FunctionType)), update_function),
  147.     ((lambda a, b: isinstance2(a, b, property)), update_property),
  148.     ((lambda a, b: isinstance2(a, b, types.MethodType)), (lambda a, b: update_function(a.im_func, b.im_func)))]
  149.  
  150. def update_generic(a, b):
  151.     for type_check, update in UPDATE_RULES:
  152.         if type_check(a, b):
  153.             update(a, b)
  154.             return True
  155.     
  156.     return False
  157.  
  158.  
  159. class StrongRef(object):
  160.     
  161.     def __init__(self, obj):
  162.         self.obj = obj
  163.  
  164.     
  165.     def __call__(self):
  166.         return self.obj
  167.  
  168.  
  169.  
  170. def superreload(module, reload = reload, old_objects = { }):
  171.     for name, obj in module.__dict__.items():
  172.         if not hasattr(obj, '__module__') or obj.__module__ != module.__name__:
  173.             continue
  174.         
  175.         key = (module.__name__, name)
  176.         
  177.         try:
  178.             old_objects.setdefault(key, []).append(weakref.ref(obj))
  179.         continue
  180.         except TypeError:
  181.             if isinstance(obj, types.ClassType):
  182.                 old_objects.setdefault(key, []).append(StrongRef(obj))
  183.             
  184.             isinstance(obj, types.ClassType)
  185.         
  186.  
  187.     
  188.     
  189.     try:
  190.         old_name = module.__name__
  191.         module.__dict__.clear()
  192.         module.__dict__['__name__'] = old_name
  193.     except (TypeError, AttributeError, KeyError):
  194.         None<EXCEPTION MATCH>TypeError
  195.         None<EXCEPTION MATCH>TypeError
  196.     except:
  197.         None<EXCEPTION MATCH>TypeError
  198.  
  199.     module = reload(module)
  200.     for name, new_obj in module.__dict__.items():
  201.         key = (module.__name__, name)
  202.         if key not in old_objects:
  203.             continue
  204.         
  205.         new_refs = []
  206.         for old_ref in old_objects[key]:
  207.             old_obj = old_ref()
  208.             if old_obj is None:
  209.                 continue
  210.             
  211.             new_refs.append(old_ref)
  212.             update_generic(old_obj, new_obj)
  213.         
  214.         if new_refs:
  215.             old_objects[key] = new_refs
  216.             continue
  217.         del old_objects[key]
  218.     
  219.     return module
  220.  
  221. reloader = ModuleReloader()
  222. import IPython.ipapi as IPython
  223. ip = IPython.ipapi.get()
  224. autoreload_enabled = False
  225.  
  226. def runcode_hook(self):
  227.     if not autoreload_enabled:
  228.         raise IPython.ipapi.TryNext
  229.     autoreload_enabled
  230.     
  231.     try:
  232.         reloader.check()
  233.     except:
  234.         pass
  235.  
  236.  
  237.  
  238. def enable_autoreload():
  239.     global autoreload_enabled
  240.     autoreload_enabled = True
  241.  
  242.  
  243. def disable_autoreload():
  244.     global autoreload_enabled
  245.     autoreload_enabled = False
  246.  
  247.  
  248. def autoreload_f(self, parameter_s = ''):
  249.     if parameter_s == '':
  250.         reloader.check(True)
  251.     elif parameter_s == '0':
  252.         disable_autoreload()
  253.     elif parameter_s == '1':
  254.         reloader.check_all = False
  255.         enable_autoreload()
  256.     elif parameter_s == '2':
  257.         reloader.check_all = True
  258.         enable_autoreload()
  259.     
  260.  
  261.  
  262. def aimport_f(self, parameter_s = ''):
  263.     modname = parameter_s
  264.     if not modname:
  265.         to_reload = reloader.modules.keys()
  266.         to_reload.sort()
  267.         to_skip = reloader.skip_modules.keys()
  268.         to_skip.sort()
  269.         if reloader.check_all:
  270.             print 'Modules to reload:\nall-expect-skipped'
  271.         else:
  272.             print 'Modules to reload:\n%s' % ' '.join(to_reload)
  273.         print '\nModules to skip:\n%s' % ' '.join(to_skip)
  274.     elif modname.startswith('-'):
  275.         modname = modname[1:]
  276.         
  277.         try:
  278.             del reloader.modules[modname]
  279.         except KeyError:
  280.             pass
  281.  
  282.         reloader.skip_modules[modname] = True
  283.     else:
  284.         
  285.         try:
  286.             del reloader.skip_modules[modname]
  287.         except KeyError:
  288.             pass
  289.  
  290.         reloader.modules[modname] = True
  291.         __import__(modname)
  292.         basename = modname.split('.')[0]
  293.         mod = sys.modules[basename]
  294.         ip.to_user_ns({
  295.             basename: mod })
  296.  
  297.  
  298. def init():
  299.     ip.expose_magic('autoreload', autoreload_f)
  300.     ip.expose_magic('aimport', aimport_f)
  301.     ip.set_hook('pre_runcode_hook', runcode_hook)
  302.  
  303. init()
  304.