def resolve_parents(root_name): """Given the name of a dependency, return all dependencies and packages that require that dependency, directly or indirectly. """ manager = PackageManager() everything = manager.list_packages() + manager.list_dependencies() recursive_dependencies = set() dependency_relationships = { name: manager.get_dependencies(name) for name in everything } def rec(name): if name in recursive_dependencies: return recursive_dependencies.add(name) for pkg_name in everything: if name in dependency_relationships[pkg_name]: rec(pkg_name) rec(root_name) recursive_dependencies.remove(root_name) return recursive_dependencies
def resolve_dependencies(root_name): """Given the name of a dependency, return all dependencies and packages that require that dependency, directly or indirectly. """ manager = PackageManager() all_packages = manager.list_packages() all_dependencies = manager.list_dependencies() recursive_dependencies = set() dependent_packages = set() dependency_relationships = { name: manager.get_dependencies(name) for name in all_packages + all_dependencies } def rec(name): if name in recursive_dependencies: return recursive_dependencies.add(name) for dep_name in all_dependencies: if name in dependency_relationships[dep_name]: rec(dep_name) for pkg_name in all_packages: if name in dependency_relationships[pkg_name]: dependent_packages.add(pkg_name) rec(root_name) return (recursive_dependencies, dependent_packages)
class PHPIDE(threading.Thread): def __init__(self): self.manager = PackageManager() threading.Thread.__init__(self) def run(self): installed_packages = self.manager.list_packages() for plugin in Prefs.plugins: print "- checking plugin " + plugin if not plugin in installed_packages: self.manager.install_package(plugin)
def __init__(self): sublime_dir = os.path.dirname(sublime.packages_path()) installed_packages_dir = os.path.join(sublime_dir, 'Installed Packages') packages_dir = os.path.join(sublime_dir, 'Packages') self.user_dir = os.path.join(packages_dir, 'User') package_control = os.path.join(installed_packages_dir, "Package Control.sublime-package") sys.path.append(package_control) from package_control.package_manager import PackageManager self.package_control = PackageManager()
def chain_update(remove_packages, install_packages, processes, on_complete=None): manager = PackageManager() remove_queue = remove_packages[:] install_queue = install_packages[:] processes_queue = processes[:] def launch_next(): if remove_queue: package = remove_queue.pop(0) time.sleep(0.2) remove(manager, package, on_complete=launch_next) elif install_queue: package = install_queue.pop(0) time.sleep(0.2) install(manager, package, on_complete=launch_next) elif processes_queue: process = processes_queue.pop(0) time.sleep(0.2) process.update(on_complete=launch_next) elif on_complete: sublime.set_timeout(on_complete, 1000) launch_next()
def install_amxx_editor_menu_on_first_run(): # https://packagecontrol.io/docs/events from package_control import events if events.install(CURRENT_PACKAGE_NAME): log(1, 'Installed %s!', events.install(CURRENT_PACKAGE_NAME)) from package_control.package_manager import PackageManager package_manager = PackageManager() all_packages = set(package_manager.list_packages()) if AMXX_CHANNEL in all_packages: amxx_channel_path = os.path.join(PACKAGE_ROOT_DIRECTORY, AMXX_CHANNEL) if not os.path.exists(amxx_channel_path): add_main_menu()
def get_installed_packages(exclusion_list=[], list_default_packages=False, list_dependencies=False): if PackageManager: packages = [] package_manager = PackageManager() if list_default_packages: packages.extend(package_manager.list_default_packages()) if list_dependencies: packages.extend(package_manager.list_dependencies()) packages.extend(package_manager.list_packages()) return list(set(packages) - set(exclusion_list)) else: raise ImportError( "You can only use the Sublime Text API inside Sublime Text.")
def reload_dependency(dependency_name, dummy=True, verbose=True): """ Reload a Package Control dependency. Package Control dependencies aren't regular packages, so we don't want to call `sublime_plugin.unload_module` or `sublime_plugin.reload_plugin`. Instead, we manually unload all of the modules in the dependency and then `reload_package` any packages that use that dependency. (We have to manually unload the dependency's modules because calling `reload_package` on a dependent module will not unload the dependency.) """ for name in get_package_modules(dependency_name): del sys.modules[name] manager = PackageManager() for package in manager.list_packages(): if dependency_name in manager.get_dependencies(package): reload_package(package, dummy=False, verbose=verbose) if dummy: load_dummy(verbose)
def _try_uninstall_package_control(): silence_error_message_box(63.0) g_settings.disable_package_control_uninstaller() # Keeps it running continually because something is setting it back, enabling Package Control again g_settings.setup_packages_ignored_list( package_disabler, packages_to_add=packages_to_ignore) # Wait some time until `Package Control` finally get ignored for interval in range(0, 10): safe_remove(g_package_control_package) safe_remove(g_package_control_loader_file) safe_remove(g_package_control_loader_file + "-new") time.sleep(0.1) time.sleep(IGNORE_PACKAGE_MINIMUM_WAIT_TIME) package_manager = PackageManager() package_manager.remove_package(PACKAGE_CONTROL_NAME, False) package_manager.remove_package(PACKAGE_CONTROL_LOADER_NAME, False) safe_remove(g_package_control_package) safe_remove(g_package_control_loader_file) safe_remove(g_package_control_loader_file + "-new") _remove_package_control_from_installed_packages_setting( g_settings.packagesmanager_setting_path()) _remove_package_control_from_installed_packages_setting( g_settings.package_control_setting_path())
def reload_dependency(dependency_name, dummy=True, verbose=True): """ Package Control dependencies aren't regular packages, so we don't want to call `sublime_plugin.unload_module` or `sublime_plugin.reload_plugin`. Instead, we manually unload all of the modules in the dependency and then `reload_package` any packages that use that dependency. (We have to manually unload the dependency's modules because calling `reload_package` on a dependent module will not unload the dependency.) """ dependency_base = os.path.join(sublime.packages_path(), dependency_name) + os.sep for module in list(sys.modules.values()): if getattr(module, '__file__', '').startswith(dependency_base): del sys.modules[module.__name__] manager = PackageManager() for package in manager.list_packages(): if dependency_name in manager.get_dependencies(package): reload_package(package, dummy=False, verbose=verbose) if dummy: load_dummy(verbose)
class PackageController: user_dir = None def __init__(self): sublime_dir = os.path.dirname(sublime.packages_path()) installed_packages_dir = os.path.join(sublime_dir, 'Installed Packages') packages_dir = os.path.join(sublime_dir, 'Packages') self.user_dir = os.path.join(packages_dir, 'User') package_control = os.path.join(installed_packages_dir, "Package Control.sublime-package") sys.path.append(package_control) from package_control.package_manager import PackageManager self.package_control = PackageManager() def install_packages(self, packages, callback=lambda: True, wipe_others=True): if wipe_others: installed_packages = self.package_control.list_packages() to_remove = [] for pkg in installed_packages: if pkg not in packages: to_remove.append(pkg) to_install = [] for pkg in packages: if pkg in installed_packages: continue to_install.append(pkg) PackageResolver(self.package_control, to_install, to_remove, callback).start() def reload(self): # We have to delete `Package Control.last-run` to not run into the cache last_run_file = os.path.join(self.user_dir, "Package Control.last-run") if os.path.isfile(last_run_file): os.remove(last_run_file) from package_control.package_cleanup import PackageCleanup sublime.set_timeout(lambda: PackageCleanup().start(), 2000)
def plugin_loaded(): global g_main_directory g_main_directory = g_settings.main_directory() global g_package_control_directory g_package_control_directory = os.path.join(g_main_directory, "Packages", PACKAGE_CONTROL_NAME) global g_package_control_package g_package_control_package = os.path.join( g_main_directory, "Installed Packages", "%s.sublime-package" % PACKAGE_CONTROL_NAME) global g_package_control_loader_file g_package_control_loader_file = os.path.join( g_main_directory, "Installed Packages", "%s.sublime-package" % PACKAGE_CONTROL_LOADER_NAME) manager = PackageManager() settings = manager.settings.copy() threading.Thread(target=_background_bootstrap, args=(settings, )).start() threading.Thread(target=configure_package_control_uninstaller).start()
def __init__(self): self.manager = PackageManager() threading.Thread.__init__(self)
def is_dependency(pkg_name): return PackageManager()._is_dependency(pkg_name)
def plugin_loaded(): manager = PackageManager() settings = manager.settings.copy() if not loader.exists('package_control'): base_loader_code = """ import sys import os from os.path import dirname # This file adds the package_control subdirectory of Package Control # to first in the sys.path so that all other packages may rely on # PC for utility functions, such as event helpers, adding things to # sys.path, downloading files from the internet, etc if sys.version_info >= (3,): def decode(path): return path def encode(path): return path loader_dir = dirname(__file__) else: def decode(path): if not isinstance(path, unicode): path = path.decode(sys.getfilesystemencoding()) return path def encode(path): if isinstance(path, unicode): path = path.encode(sys.getfilesystemencoding()) return path loader_dir = decode(os.getcwd()) st_dir = dirname(dirname(loader_dir)) found = False if sys.version_info >= (3,): installed_packages_dir = os.path.join(st_dir, u'Installed Packages') pc_package_path = os.path.join(installed_packages_dir, u'Package Control.sublime-package') if os.path.exists(encode(pc_package_path)): found = True if not found: packages_dir = os.path.join(st_dir, u'Packages') pc_package_path = os.path.join(packages_dir, u'Package Control') if os.path.exists(encode(pc_package_path)): found = True if found: if os.name == 'nt': from ctypes import windll, create_unicode_buffer buf = create_unicode_buffer(512) if windll.kernel32.GetShortPathNameW(pc_package_path, buf, len(buf)): pc_package_path = buf.value sys.path.insert(0, encode(pc_package_path)) import package_control # We remove the import path right away so as not to screw up # Sublime Text and its import machinery sys.path.remove(encode(pc_package_path)) else: print(u'Package Control: Error finding main directory from loader') """ base_loader_code = dedent(base_loader_code).lstrip() loader.add('00', 'package_control', base_loader_code) # SSL support fo Linux if sublime.platform() == 'linux': linux_ssl_url = u'http://packagecontrol.io/ssl/1.0.1/ssl-linux.sublime-package' linux_ssl_hash = u'862d061cbe666777cd1e9cd1cbc7c82f48ad8897dbb68332975f3edf5ce0f38d' linux_ssl_priority = u'01' linux_ssl_version = '1.0.1' def linux_ssl_show_restart(): sublime.message_dialog(text.format( u''' Package Control Package Control just installed or upgraded the missing Python _ssl module for Linux since Sublime Text does not include it. Please restart Sublime Text to make SSL available to all packages. ''' )) linux_ssl_args = (settings, linux_ssl_url, linux_ssl_hash, linux_ssl_priority, linux_ssl_version, linux_ssl_show_restart) threading.Thread(target=bootstrap_dependency, args=linux_ssl_args).start() # SSL support for SHA-2 certificates with ST2 on Windows if sublime.platform() == 'windows' and sys.version_info < (3,): win_ssl_url = u'http://packagecontrol.io/ssl/1.0.0/ssl-windows.sublime-package' win_ssl_hash = u'3c28982eb400039cfffe53d38510556adead39ba7321f2d15a6770d3ebc75030' win_ssl_priority = u'01' win_ssl_version = u'1.0.0' def win_ssl_show_restart(): sublime.message_dialog(text.format( u''' Package Control Package Control just upgraded the Python _ssl module for ST2 on Windows because the bundled one does not include support for modern SSL certificates. Please restart Sublime Text to complete the upgrade. ''' )) win_ssl_args = (settings, win_ssl_url, win_ssl_hash, win_ssl_priority, win_ssl_version, win_ssl_show_restart) threading.Thread(target=bootstrap_dependency, args=win_ssl_args).start() pc_settings = sublime.load_settings(pc_settings_filename()) # Make sure we are track Package Control itself installed_packages = load_list_setting(pc_settings, 'installed_packages') if 'Package Control' not in installed_packages: params = { 'package': 'Package Control', 'operation': 'install', 'version': package_control.__version__ } manager.record_usage(params) installed_packages.append('Package Control') save_list_setting(pc_settings, pc_settings_filename(), 'installed_packages', installed_packages) # We no longer use the installed_dependencies setting because it is not # necessary and created issues with settings shared across operating systems if pc_settings.get('installed_dependencies'): pc_settings.erase('installed_dependencies') sublime.save_settings(pc_settings_filename())
from .typing import List, Tuple try: from package_control.package_manager import PackageManager # type: ignore manager = PackageManager() def get_dependency_relationships() -> List[Tuple[str, str]]: return [ (name, dep) for name in (manager.list_packages() + manager.list_dependencies()) for dep in manager.get_dependencies(name) ] except ImportError: # pragma: nocoverage def get_dependency_relationships() -> List[Tuple[str, str]]: return []
def ensure_dependencies_loaded() -> None: for dependency in PackageManager().get_dependencies(PACKAGE_NAME): add_dependency(dependency)
def plugin_loaded(): manager = PackageManager() settings = manager.settings.copy() if not os.path.exists(loader.loader_package_path): base_loader_code = """ import sys import os from os.path import dirname # This file adds the package_control subdirectory of Package Control # to first in the sys.path so that all other packages may rely on # PC for utility functions, such as event helpers, adding things to # sys.path, downloading files from the internet, etc if sys.version_info >= (3,): def decode(path): return path def encode(path): return path loader_dir = dirname(__file__) else: def decode(path): if not isinstance(path, unicode): path = path.decode(sys.getfilesystemencoding()) return path def encode(path): if isinstance(path, unicode): path = path.encode(sys.getfilesystemencoding()) return path loader_dir = decode(os.getcwd()) st_dir = dirname(dirname(loader_dir)) found = False if sys.version_info >= (3,): installed_packages_dir = os.path.join(st_dir, u'Installed Packages') pc_package_path = os.path.join(installed_packages_dir, u'Package Control.sublime-package') if os.path.exists(encode(pc_package_path)): found = True if not found: packages_dir = os.path.join(st_dir, u'Packages') pc_package_path = os.path.join(packages_dir, u'Package Control') if os.path.exists(encode(pc_package_path)): found = True if found: if os.name == 'nt': from ctypes import windll, create_unicode_buffer buf = create_unicode_buffer(512) if windll.kernel32.GetShortPathNameW(pc_package_path, buf, len(buf)): pc_package_path = buf.value sys.path.insert(0, encode(pc_package_path)) import package_control # We remove the import path right away so as not to screw up # Sublime Text and its import machinery sys.path.remove(encode(pc_package_path)) else: print(u'Package Control: Error finding main directory from loader') """ base_loader_code = dedent(base_loader_code) loader.add('00', 'package_control', base_loader_code) pc_settings = sublime.load_settings(pc_settings_filename()) # Make sure we are track Package Control itself installed_packages = load_list_setting(pc_settings, 'installed_packages') if 'Package Control' not in installed_packages: installed_packages.append('Package Control') save_list_setting(pc_settings, pc_settings_filename(), 'installed_packages', installed_packages) orig_installed_dependencies = load_list_setting(pc_settings, 'installed_dependencies') installed_dependencies = list(orig_installed_dependencies) # Record that the loader itself is installed if loader.loader_package_name not in installed_dependencies: installed_dependencies.append(loader.loader_package_name) # Queue up installation of bz2 if 'bz2' not in installed_dependencies: installed_dependencies.append('bz2') # Queue up installation of select module for ST2/Windows if sublime.platform() == 'windows' and sys.version_info < ( 3, ) and 'select-windows' not in installed_dependencies: installed_dependencies.append('select-windows') save_list_setting(pc_settings, pc_settings_filename(), 'installed_dependencies', installed_dependencies, orig_installed_dependencies) # SSL support fo Linux if sublime.platform() == 'linux': linux_ssl_url = u'http://packagecontrol.io/ssl-linux.sublime-package' linux_ssl_hash = u'bd107e93065aa8520749fe37d9d15afc40af75c5ccbdcdb14966b7db162032d2' linux_ssl_priority = u'01' def linux_ssl_show_restart(): sublime.message_dialog(u'Package Control\n\n' u'Package Control just installed the missing Python _ssl ' + \ u'module for Linux since Sublime Text does not include it.\n\n' + \ u'Please restart Sublime Text to make SSL available to all ' + \ u'packages.') linux_ssl_args = (settings, linux_ssl_url, linux_ssl_hash, linux_ssl_priority, linux_ssl_show_restart) threading.Thread(target=bootstrap_dependency, args=linux_ssl_args).start() # SSL support for SHA-2 certificates with ST2 on Windows if sublime.platform() == 'windows' and sys.version_info < (3, ): win_ssl_url = u'http://packagecontrol.io/ssl-windows.sublime-package' win_ssl_hash = u'3c28982eb400039cfffe53d38510556adead39ba7321f2d15a6770d3ebc75030' win_ssl_priority = u'01' def win_ssl_show_restart(): sublime.message_dialog(u'Package Control\n\n' u'Package Control just upgraded the Python _ssl module for ' + \ u'ST2 on Windows because the bundled one does not include ' + \ u'support for modern SSL certificates.\n\n' + \ u'Please restart Sublime Text to complete the upgrade.') win_ssl_args = (settings, win_ssl_url, win_ssl_hash, win_ssl_priority, win_ssl_show_restart) threading.Thread(target=bootstrap_dependency, args=win_ssl_args).start()
def plugin_loaded(): manager = PackageManager() settings = manager.settings.copy() if not loader.exists('package_control'): base_loader_code = """ import sys import os from os.path import dirname # This file adds the package_control subdirectory of Package Control # to first in the sys.path so that all other packages may rely on # PC for utility functions, such as event helpers, adding things to # sys.path, downloading files from the internet, etc if sys.version_info >= (3,): def decode(path): return path def encode(path): return path loader_dir = dirname(__file__) else: def decode(path): if not isinstance(path, unicode): path = path.decode(sys.getfilesystemencoding()) return path def encode(path): if isinstance(path, unicode): path = path.encode(sys.getfilesystemencoding()) return path loader_dir = decode(os.getcwd()) st_dir = dirname(dirname(loader_dir)) found = False if sys.version_info >= (3,): installed_packages_dir = os.path.join(st_dir, u'Installed Packages') pc_package_path = os.path.join(installed_packages_dir, u'Package Control.sublime-package') if os.path.exists(encode(pc_package_path)): found = True if not found: packages_dir = os.path.join(st_dir, u'Packages') pc_package_path = os.path.join(packages_dir, u'Package Control') if os.path.exists(encode(pc_package_path)): found = True if found: if os.name == 'nt': from ctypes import windll, create_unicode_buffer buf = create_unicode_buffer(512) if windll.kernel32.GetShortPathNameW(pc_package_path, buf, len(buf)): pc_package_path = buf.value sys.path.insert(0, encode(pc_package_path)) import package_control # We remove the import path right away so as not to screw up # Sublime Text and its import machinery sys.path.remove(encode(pc_package_path)) else: print(u'Package Control: Error finding main directory from loader') """ base_loader_code = dedent(base_loader_code).lstrip() loader.add('00', 'package_control', base_loader_code) # SSL support fo Linux if sublime.platform() == 'linux': linux_ssl_url = u'http://packagecontrol.io/ssl/1.0.1/ssl-linux.sublime-package' linux_ssl_hash = u'862d061cbe666777cd1e9cd1cbc7c82f48ad8897dbb68332975f3edf5ce0f38d' linux_ssl_priority = u'01' linux_ssl_version = '1.0.1' def linux_ssl_show_restart(): sublime.message_dialog( text.format(u''' Package Control Package Control just installed or upgraded the missing Python _ssl module for Linux since Sublime Text does not include it. Please restart Sublime Text to make SSL available to all packages. ''')) threading.Thread(target=bootstrap_dependency, args=( settings, linux_ssl_url, linux_ssl_hash, linux_ssl_priority, linux_ssl_version, linux_ssl_show_restart, )).start() # SSL support for SHA-2 certificates with ST2 on Windows elif sublime.platform() == 'windows' and sys.version_info < (3, ): win_ssl_url = u'http://packagecontrol.io/ssl/1.0.0/ssl-windows.sublime-package' win_ssl_hash = u'3c28982eb400039cfffe53d38510556adead39ba7321f2d15a6770d3ebc75030' win_ssl_priority = u'01' win_ssl_version = u'1.0.0' def win_ssl_show_restart(): sublime.message_dialog( text.format(u''' Package Control Package Control just upgraded the Python _ssl module for ST2 on Windows because the bundled one does not include support for modern SSL certificates. Please restart Sublime Text to complete the upgrade. ''')) threading.Thread(target=bootstrap_dependency, args=( settings, win_ssl_url, win_ssl_hash, win_ssl_priority, win_ssl_version, win_ssl_show_restart, )).start() else: mark_bootstrapped()
def plugin_loaded(): # tool_settings = sublime.load_settings('RansTool.sublime-settings') # previous_version = tuple_ver(tool_settings.get("previous_version", "0.0.0")) # if tool_settings.get('bootstrapped') is True and previous_version == (0, 0, 0): # previous_version = (0, 0, 1) # current_version = tuple_ver(tool_settings.get("current_version")) progress_memory = ToolProgressMemory() previous_version, current_version = progress_memory.load_progress_version() candidate_remove = [] candidate_install = [] for since, removes, installs in pakages_since: since = tuple_ver(since) if previous_version < since <= current_version: for rm in removes: if rm in candidate_install: candidate_install.remove(rm) elif rm not in candidate_remove: candidate_remove.append(rm) for ins in installs: if ins in candidate_remove: candidate_remove.remove(ins) elif ins not in candidate_install: candidate_install.append(ins) confighome = os.environ.get('XDG_CONFIG_HOME', os.path.expanduser('~/.config')) configpath = os.environ.get('ST_LIFE_USERCONFIG_PATH', os.path.join(confighome, 'sublime-life')) extra_packages_file = os.path.join(configpath, 'extra-packages.ini') if os.path.exists(extra_packages_file): with open(extra_packages_file) as f: extra_packages = [ pkg.strip() for pkg in f.readlines() if pkg.strip() ] for expkg in extra_packages: if expkg in candidate_remove: candidate_remove.remove(expkg) elif expkg not in candidate_install: candidate_install.append(expkg) installed_packages = PackageManager().list_packages() remove_packages = [] install_packages = [] for inspkg in candidate_install: if inspkg in installed_packages: print( 'RanTool install {} (Skip, already installed)'.format(inspkg)) else: print('RanTool install {}'.format(inspkg)) install_packages.append(inspkg) for rmpkg in candidate_remove: if rmpkg not in installed_packages: print('RanTool remove {} (Skip, not exist)'.format(rmpkg)) else: print('RanTool remove {}'.format(rmpkg)) remove_packages.append(rmpkg) processes = [] for p in UpdateProcess.update_processes: if previous_version < p.since <= current_version: processes.append(p) def on_complete(): progress_memory.save_progress_version(current_version) # tool_settings.set('previous_version', string_ver(current_version)) # sublime.save_settings('RansTool.sublime-settings') if remove_packages or install_packages or processes: if previous_version == (0, 0, 0): sublime.active_window().status_message( "Sublime Life is successful installed") else: sublime.active_window().status_message( "Sublime Life is successful updated") else: sublime.active_window().status_message( "Sublime Life is nothing to update") chain_update(remove_packages, install_packages, processes, on_complete=on_complete)
def install_sublime_linter(self): from package_control.package_manager import PackageManager manager = PackageManager() manager.install_package("SublimeLinter")
def plugin_loaded(): manager = PackageManager() settings = manager.settings.copy() threading.Thread(target=_background_bootstrap, args=(settings, )).start()