def reload_package(pkg_name, dummy=True): if pkg_name not in sys.modules: dprint("error:", pkg_name, "is not loaded.") return main = sys.modules[pkg_name] dprint("begin", fill='=') modules = {main.__name__: main} modules.update({name: module for name, module in sys.modules.items() if name.startswith(pkg_name + ".")}) for m in modules: if m in sys.modules: sublime_plugin.unload_module(modules[m]) del sys.modules[m] try: with intercepting_imports(modules), \ importing_fromlist_aggresively(modules): reload_plugin(main.__name__) reload_missing(modules) except: dprint("reload failed.", fill='-') raise if dummy: load_dummy() dprint("end", fill='-')
def reload_package(pkg_name, dummy=True, verbose=True): if pkg_name not in sys.modules: dprint("error:", pkg_name, "is not loaded.") return main = sys.modules[pkg_name] if verbose: dprint("begin", fill='=') modules = {main.__name__: main} modules.update({name: module for name, module in sys.modules.items() if name.startswith(pkg_name + ".")}) for m in modules: if m in sys.modules: sublime_plugin.unload_module(modules[m]) del sys.modules[m] try: with intercepting_imports(modules, verbose), \ importing_fromlist_aggresively(modules): reload_plugin(main.__name__) except Exception: dprint("reload failed.", fill='-') reload_missing(modules, verbose) raise if dummy: load_dummy(verbose) if verbose: dprint("end", fill='-')
def reload_package(pkg_name, dummy=True, verbose=True): if is_dependency(pkg_name): reload_dependency(pkg_name, dummy, verbose) return if pkg_name not in sys.modules: dprint("error:", pkg_name, "is not loaded.") return if verbose: dprint("begin", fill='=') modules = get_package_modules(pkg_name) for m in modules: if m in sys.modules: sublime_plugin.unload_module(modules[m]) del sys.modules[m] try: with intercepting_imports(modules, verbose), \ importing_fromlist_aggresively(modules): reload_plugin(pkg_name) except Exception: dprint("reload failed.", fill='-') reload_missing(modules, verbose) raise if dummy: load_dummy(verbose) if verbose: dprint("end", fill='-')
def reload_package(pkg_name, dummy=True, verbose=True, then=None): if pkg_name not in sys.modules: dprint("error:", pkg_name, "is not loaded.") return if is_dependency(pkg_name): dependencies, packages = resolve_dependencies(pkg_name) else: dependencies = set() packages = {pkg_name} if verbose: dprint("begin", fill='=') all_modules = { module_name: module for pkg_name in dependencies | packages for module_name, module in get_package_modules(pkg_name).items() } # Tell Sublime to unload plugins for pkg_name in packages: for plugin in package_plugins(pkg_name): module = sys.modules.get(plugin) if module: sublime_plugin.unload_module(module) # Unload modules for module_name in all_modules: sys.modules.pop(module_name) # Reload packages try: with intercepting_imports( all_modules, verbose), importing_fromlist_aggresively(all_modules): for pkg_name in packages: for plugin in package_plugins(pkg_name): sublime_plugin.reload_plugin(plugin) except Exception: dprint("reload failed.", fill='-') reload_missing(all_modules, verbose) raise if dummy: load_dummy(verbose) if verbose: dprint("end", fill='-') if then: then() sublime.active_window().status_message('GitSavvy has 🙌 reloaded.')
def reload_package(package, dependencies=[], dummy=True, verbose=True): if verbose: dprint("begin", fill='=') if dummy: load_dummy(verbose) packages = [package] + dependencies parents = set() for package in packages: for parent in resolve_parents(package): parents.add(parent) parents = list(parents) modules = sorted(list(set(get_package_modules(packages + parents))), key=lambda x: x[0].split('.')) plugins = [m for m, is_plugin in modules if is_plugin] # Tell Sublime to unload plugin_modules for plugin in plugins: if plugin in sys.modules: sublime_plugin.unload_module(sys.modules[plugin]) # these are modules marked to be reloaded, they are not necessarily reloaded modules_to_reload = [ sys.modules[m] for m, is_plugin in modules if m in sys.modules ] with ReloadingImporter(modules_to_reload, verbose) as importer: if plugins: # we only reload top level plugin_modules to mimic Sublime Text natural order for plugin in plugins: if plugin in sys.modules: module = sys.modules[plugin] importer.reload(module) for plugin in plugins: if plugin in sys.modules: module = sys.modules[plugin] sublime_plugin.load_module(module) else: # in case we missed something sublime_plugin.reload_plugin(plugin) else: # it is possibly a dependency but no packages use it for module in modules_to_reload: importer.reload(module) if dummy: load_dummy(verbose) if verbose: dprint("end", fill='-')
def reload_package(pkg_name, dummy=True, verbose=True): if pkg_name not in sys.modules: dprint("error:", pkg_name, "is not loaded.") return if is_dependency(pkg_name): dependencies, packages = resolve_dependencies(pkg_name) else: dependencies = set() packages = {pkg_name} if verbose: dprint("begin", fill='=') all_modules = { module_name: module for pkg_name in dependencies | packages for module_name, module in get_package_modules(pkg_name).items() } # Tell Sublime to unload plugins for pkg_name in packages: for plugin in package_plugins(pkg_name): module = sys.modules.get(plugin) if module: sublime_plugin.unload_module(module) # Unload modules for module_name in all_modules: sys.modules.pop(module_name) # Reload packages try: with intercepting_imports(all_modules, verbose), importing_fromlist_aggresively(all_modules): for pkg_name in packages: for plugin in package_plugins(pkg_name): sublime_plugin.reload_plugin(plugin) except Exception: dprint("reload failed.", fill='-') reload_missing(all_modules, verbose) raise if dummy: load_dummy(verbose) if verbose: dprint("end", fill='-')
def reload_packages(packages: Iterable[str]) -> None: packages = get_dependents(packages, get_dependency_relationships()) modules = list(get_package_modules(packages)) sorted_modules = sorted([module for module, path in modules], key=lambda module: module.__name__.split('.')) plugins = [module for module, path in modules if len(path.parts) == 3] for module in plugins: sublime_plugin.unload_module(module) with ReloadingImporter(sorted_modules) as reload: for module in sorted_modules: try: reload(module) except FileNotFoundError as e: print(e) for module in plugins: sublime_plugin.load_module(module)
def monitor_plugins(): """Monitor for any plugin that conflicts with anaconda """ view = sublime.active_window().active_view() if not get_settings(view, 'auto_unload_conflictive_plugins', True): return plist = [ 'Jedi - Python autocompletion', # breaks auto completion 'SublimePythonIDE', # interfere with autocompletion 'SublimeCodeIntel' # breaks everything, SCI is a mess ] hllist = [ 'MagicPython', # breaks autocompletion on [dot] 'Python 3' # breeaks autocompletion on [dot] ] for plugin in plist: if plugin in sys.modules: [ sublime_plugin.unload_module(m) for k, m in sys.modules.items() if plugin in k ] if plugin not in DISABLED_PLUGINS: DISABLED_PLUGINS.append(plugin) for highlighter in hllist: paths = os.listdir(sublime.packages_path()) + \ os.listdir(sublime.installed_packages_path()) for p in paths: if highlighter in p: fname = '{0}.sublime-settings'.format(highlighter) s = sublime.load_settings(fname) if all((s.has('auto_complete_triggers'), s.has('extensions'))): break auto_complete = [ { 'characters': '.', 'selector': 'source.python - string - constant.numeric', # noqa } ] s.set('extensions', ['py']) s.set('auto_complete_triggers', auto_complete) sublime.save_settings(fname) break sublime.set_timeout_async(monitor_plugins, 500000)
def monitor_plugins(): """Monitor for any plugin that conflicts with anaconda """ view = sublime.active_window().active_view() if not get_settings(view, 'auto_unload_conflictive_plugins', True): return plist = [ 'Jedi - Python autocompletion', # breaks auto completion 'SublimePythonIDE', # interfere with autocompletion 'SublimeCodeIntel' # breaks everything, SCI is a mess ] for plugin in plist: if plugin in sys.modules: [ sublime_plugin.unload_module(m) for k, m in sys.modules.items() if plugin in k ] if plugin not in DISABLED_PLUGINS: DISABLED_PLUGINS.append(plugin) sublime.set_timeout_async(monitor_plugins, 5 * 60 * 1000)
def monitor_plugins(): """Monitor for any plugin that conflicts with anaconda """ view = sublime.active_window().active_view() if not get_settings(view, 'auto_unload_conflictive_plugins', True): return plist = [ 'Jedi - Python autocompletion', # breaks auto completion 'SublimePythonIDE', # interfere with autocompletion 'SublimeCodeIntel' # breaks everything, SCI is a mess ] for plugin in plist: if plugin in sys.modules: [ sublime_plugin.unload_module(m) for k, m in sys.modules.items() if plugin in k ] if plugin not in DISABLED_PLUGINS: DISABLED_PLUGINS.append(plugin) sublime.set_timeout_async(monitor_plugins, 5*60*1000)
def reload_modules(main, modules, perform_reload=True): """Implements the machinery for reloading a given plugin module.""" # # Here's the approach in general: # # - Hide package modules from the sys.modules temporarily; # # - Install a special import hook onto sys.meta_path; # # - Call sublime_plugin.reload_plugin(), which imports the main # module under the hood, triggering the hook; # # - The hook, instead of creating a new module object, peeks the saved # one and reloads it. Once the module encounters an import statement # requesting another module, not yet reloaded, the hook reenters and # processes that new module recursively, then get back to the previous # one, and so on. # # This makes the modules reload in the very same order as they were loaded # initially, as if they were imported from scratch. # if perform_reload: sublime_plugin.unload_module(main) # Insert the main module at the beginning to make the reload # order be as close to the order of the "natural" import as possible. module_names = [main.__name__] + sorted(name for name in modules if name != main.__name__) # First, remove all the loaded modules from the sys.modules cache, # otherwise the reloading hook won't be called. loaded_modules = dict(sys.modules) for name in loaded_modules: if name in modules: del sys.modules[name] stack_meter = StackMeter() @FilteringImportHook.when(condition=lambda name: name in modules) def module_reloader(name): module = modules[name] sys.modules[name] = module # restore the module back if perform_reload: with stack_meter as depth: dump("reloading ", ("| " * depth) + "|-- ", name) try: return module.__loader__.load_module(name) except: if name in sys.modules: del sys.modules[name] # to indicate an error raise else: if name not in loaded_modules: dump("no reload ", "-- ", name) return module with intercepting_imports(module_reloader), \ importing_fromlist_aggresively(modules): # Now, import all the modules back, in order, starting with the main # module. This will reload all the modules directly or indirectly # referenced by the main one, i.e. usually most of our modules. log(sep="", end="") sublime_plugin.reload_plugin(main.__name__) # Be sure to bring back *all* the modules that used to be loaded, not # only these imported through the main one. Otherwise, some of them # might end up being created from scratch as new module objects in # case of being imported after detaching the hook. In general, most of # the imports below (if not all) are no-ops though. for name in module_names: importlib.import_module(name)
def reload_modules(main, modules, perform_reload=True): """Implements the machinery for reloading a given plugin module.""" # # Here's the approach in general: # # - Hide package modules from the sys.modules temporarily; # # - Install a special import hook onto sys.meta_path; # # - Call sublime_plugin.reload_plugin(), which imports the main # module under the hood, triggering the hook; # # - The hook, instead of creating a new module object, peeks the saved # one and reloads it. Once the module encounters an import statement # requesting another module, not yet reloaded, the hook reenters and # processes that new module recursively, then get back to the previous # one, and so on. # # This makes the modules reload in the very same order as they were loaded # initially, as if they were imported from scratch. # if perform_reload: sublime_plugin.unload_module(main) # Insert the main module at the beginning to make the reload # order be as close to the order of the "natural" import as possible. module_names = [main.__name__] + sorted( name for name in modules if name != main.__name__) # First, remove all the loaded modules from the sys.modules cache, # otherwise the reloading hook won't be called. loaded_modules = dict(sys.modules) for name in loaded_modules: if name in modules: del sys.modules[name] stack_meter = StackMeter() @FilteringImportHook.when(condition=lambda name: name in modules) def module_reloader(name): module = modules[name] sys.modules[name] = module # restore the module back if perform_reload: with stack_meter as depth: dump("reloading ", ("| " * depth) + "|-- ", name) try: return module.__loader__.load_module(name) except: if name in sys.modules: del sys.modules[name] # to indicate an error raise else: if name not in loaded_modules: dump("no reload ", "-- ", name) return module with intercepting_imports(module_reloader), \ importing_fromlist_aggresively(modules): # Now, import all the modules back, in order, starting with the main # module. This will reload all the modules directly or indirectly # referenced by the main one, i.e. usually most of our modules. log(sep="", end="") sublime_plugin.reload_plugin(main.__name__) # Be sure to bring back *all* the modules that used to be loaded, not # only these imported through the main one. Otherwise, some of them # might end up being created from scratch as new module objects in # case of being imported after detaching the hook. In general, most of # the imports below (if not all) are no-ops though. for name in module_names: importlib.import_module(name)
def reload_package(pkg_name, dummy=True, verbose=True, then=None): if pkg_name not in sys.modules: dprint("error:", pkg_name, "is not loaded.") return if is_dependency(pkg_name): dependencies, packages = resolve_dependencies(pkg_name) else: dependencies = set() packages = {pkg_name} if verbose: dprint("begin", fill='=') all_modules = { module_name: module for pkg_name in dependencies | packages for module_name, module in get_package_modules(pkg_name).items() } plugins = [ plugin for pkg_name in packages for plugin in package_plugins(pkg_name) ] # Tell Sublime to unload plugins for plugin in plugins: module = sys.modules.get(plugin) if module: sublime_plugin.unload_module(module) # Unload modules for module_name in all_modules: sys.modules.pop(module_name) # Reload packages try: with intercepting_imports( all_modules, verbose), importing_fromlist_aggressively(all_modules): for plugin in plugins: sublime_plugin.reload_plugin(plugin) except Exception: dprint("reload failed.", fill='-') # Rollback modules for name, module in all_modules.items(): sys.modules[name] = module # Try reloading again to get the commands back. Here esp. the # reload command itself. for plugin in plugins: sublime_plugin.reload_plugin(plugin) traceback.print_exc() print( '--- Reloading GitSavvy failed. Restarting Sublime is highly recommended. ---' ) sublime.active_window().status_message( 'GitSavvy reloading 💣ed. 😒.') return if dummy: load_dummy(verbose) if verbose: dprint("end", fill='-') if then: then() sublime.active_window().status_message('GitSavvy has 🙌 reloaded.')