Install this component (or remove and reinstall)
514012
def install(editable=True):
    """"""

    try:
        __import__(package['name'])
    except ImportError:
        pass
    else:
        run("pip uninstall --quiet -y %s" % package['name'], warn=True)

    cmd = "pip install --quiet "
    cmd += "-e ." if editable else "."

    run(cmd, warn=True)
1371237
public function install()
    {
        // 1. Set options
        $this->setOptions($this->config->options());

        // 2. Activate plugins
        $this->activatePlugins($this->config->plugins());

        // 3. Maybe set the theme (and settings)
        if ($theme = $this->config->theme()) {
            $this->setTheme($theme->name, $theme->mods, $theme->options, $theme->menus, $theme->sidebars);
        }

        // 4. Maybe set the permalink structure
        global $wp_rewrite;
        if ($wp_rewrite && $permalinks = $this->config->permalinks()) {
            $this->setPermalinkStructure($wp_rewrite, $permalinks);
        }

        // 5. Maybe set the timezone
        if ($timezone = $this->config->timezone()) {
            $this->setTimezone($timezone);
        }
    }
37721
protected function installDone()
    {
        $this->nl();
        if ($this->seemsFine) {
            $this->output->writeLn("========================================================================");
            $this->nl();
            $this->output->writeLn("                      Repair completed!");
            $this->nl();
            $this->output->writeLn("========================================================================");
        } else {
            $this->output->writeLn("Automatic installation failed to complete cleanly.");
            $this->output->writeLn("Head over to https://github.com/strata-mvc/strata/ to get help.");
        }
        $this->nl();
    }
508231
def install(self):
        """"""
        self.distro = distro_check()
        package_list = self.packages_dict.get(self.distro)
        self._installer(package_list=package_list.get('packages'))
837281
function uninstall() {
  installer.uninstall(Array.prototype.slice.call(arguments), function(errs) {
    if (errs) {
      return out.error("error : %j", errs);
    }
    return out.success("plugins uninstalled");
  });
}
386487
def reset_component(self, component):
		
		if isinstance(component, str) is True:
			component = WURI.Component(component)
		self.__components[component] = None
1202629
function install(definition, Component) {
  const Ctor = register(definition, Component);

  // no dependencies
  if (!definition.components) {
    return Ctor;
  }

  const components = definition.components || {};

  // avoid unnecessary re-registering for next time
  delete definition.components;

  // register components
  for (const name in components) {
    Ctor.component(name, register(components[name], Component));
    install(components[name], Component);
  }

  return Ctor;
}
943405
public static function install()
    {
        static::updatePackages();
        static::updateBootstrapping();

        tap(new Filesystem, function ($filesystem) {
            $filesystem->deleteDirectory(resource_path('js/components'));
            $filesystem->delete(resource_path('sass/_variables.scss'));
            $filesystem->deleteDirectory(base_path('node_modules'));
            $filesystem->deleteDirectory(public_path('css'));
            $filesystem->deleteDirectory(public_path('js'));
        });
    }
12810
private void install() {
        File directory = getNPMDirectory();
        if (directory.isDirectory()) {
            // Check the version
            String version = getVersionFromNPM(directory, log);
            // Are we looking for a specific version ?
            if (npmVersion != null) {
                // Yes
                if (!npmVersion.equals(version)) {
                    log.info("The NPM " + npmName + " is already installed but not in the requested version" +
                            " (requested: " + npmVersion + " - current: " + version + ") - uninstall it");
                    try {
                        FileUtils.deleteDirectory(directory);
                    } catch (IOException e) { //NOSONAR
                        // ignore it.
                    }
                } else {
                    log.debug("NPM " + npmName + " already installed in " + directory.getAbsolutePath() +
                            " (" + version + ")");
                    return;
                }
            } else {
                // No
                log.debug("NPM " + npmName + " already installed in " + directory.getAbsolutePath() + " " +
                        "(" + version + ")");
                return;
            }
        }

        StringBuilder command = new StringBuilder();
        command.append("install ");
        if (installArguments != null) {
            for (String s : installArguments) {
                command.append(s);
                command.append(" ");
            }
        }

        if (npmVersion != null) {
            command.append(npmName).append("@").append(npmVersion);
        } else {
            command.append(npmName);
        }

        try {
            node.factoryForNPMInstallation().getNpmRunner(node.proxy()).execute(command.toString());
        } catch (TaskRunnerException e) {
            log.error("Error during the installation of the NPM " + npmName + " - check log", e);
        }
    }
820805
function install(Vue) {
  var bus = new Vue();
  Object.defineProperty(Vue.prototype, '$bus', {
    value: bus,
    configurable: false,
    writable: false
  });

  Vue.mixin({
    created: function created() {
      var this$1 = this;

      if (this.$isServer) {
        return
      }
      var busEvents = this.$options.$_busEvents &&
        this.$options.$_busEvents.bind(this)();
      if (!busEvents) {
        return
      }
      var map = Object.create(null);
      this.$options.$_busEventsMap = map;

      Object.entries(busEvents).forEach(
        function (ref) {
          var event = ref[0];
          var listenerConfig = ref[1];

          if (Array.isArray(listenerConfig)) {
            listenerConfig.forEach(function (conf) {
              subscribeFn(event, conf, map, this$1.$bus);
            });
          } else {
            subscribeFn(event, listenerConfig, map, this$1.$bus);
          }

          function subscribeFn(_event, _conf, _map, _bus) {
            var wayToListen = _conf.once ? '$once' : '$on';
            var fn = _conf.handler ? _conf.handler.bind(this) : _conf.bind(this);

            _map[_event]
              ? _map[_event].push(fn)
              : _map[_event] = [fn];
            _bus[wayToListen](_event, fn);
          }
        }
      );
    },
    beforeDestroy: function beforeDestroy() {
      var this$1 = this;

      if (this.$isServer) {
        return
      }
      var map = this.$options.$_busEventsMap;
      if (!map) {
        return
      }
      Object.entries(map).forEach(
        function (ref) {
          var event = ref[0];
          var listeners = ref[1];

          listeners.forEach(function (item) {
            this$1.$bus.$off(event, item);
          });
        }
      );
    }
  });
}
347852
public static synchronized void install(Class<?> component) {
		Preconditions.checkState(container != null, 
				"Cannot install component until Jaguar starts");
		if (!installed(component)) {
			container.install(component);
		}
	}
553715
private function uninstallFromComposer()
    {
        $uninstallCommand = 'composer remove typicms/'.$this->module;
        if (function_exists('system')) {
            system($uninstallCommand);
        } else {
            $this->line('You can now run '.$uninstallCommand.'.');
        }
    }
536272
def sync(to_install, to_uninstall, verbose=False, dry_run=False, install_flags=None):
    
    if not to_uninstall and not to_install:
        click.echo("Everything up-to-date")

    pip_flags = []
    if not verbose:
        pip_flags += ['-q']

    if to_uninstall:
        if dry_run:
            click.echo("Would uninstall:")
            for pkg in to_uninstall:
                click.echo("  {}".format(pkg))
        else:
            check_call([sys.executable, '-m', 'pip', 'uninstall', '-y'] + pip_flags + sorted(to_uninstall))

    if to_install:
        if install_flags is None:
            install_flags = []
        if dry_run:
            click.echo("Would install:")
            for ireq in to_install:
                click.echo("  {}".format(format_requirement(ireq)))
        else:
            # prepare requirement lines
            req_lines = []
            for ireq in sorted(to_install, key=key_from_ireq):
                ireq_hashes = get_hashes_from_ireq(ireq)
                req_lines.append(format_requirement(ireq, hashes=ireq_hashes))

            # save requirement lines to a temporary file
            tmp_req_file = tempfile.NamedTemporaryFile(mode='wt', delete=False)
            tmp_req_file.write('\n'.join(req_lines))
            tmp_req_file.close()

            try:
                check_call(
                    [sys.executable, '-m', 'pip', 'install', '-r', tmp_req_file.name] + pip_flags + install_flags
                )
            finally:
                os.unlink(tmp_req_file.name)

    return 0
52869
public function install()
    {
        $grumPhpFile = $this->destination . '/grumphp.yml';

        if (file_exists($grumPhpFile)) {
            unlink($grumPhpFile);
            $this->io->write(
                sprintf(
                    '<comment>Removed:</comment> existing GrumPHP config file %s',
                    $grumPhpFile
                )
            );
        }

        $definition = $this->file->read();
        if (!empty($definition['extra']['grumphp']['config-default-path'])) {
            return;
        }

        $definition['extra']['grumphp']['config-default-path'] =
            'vendor/mediact/testing-suite/config/default/grumphp.yml';

        $this->file->write($definition);
        $this->io->write(
            '<info>Added:</info> GrumPHP config to composer.json'
        );
    }
79009
function install(Vue) {
  for (const name in components) {
    const component = components[name].component || components[name]
    Vue.component(name, component)
  }
  Vue.prototype.$actionSheet = $actionSheet
  Vue.prototype.$loading = $loading
  Vue.prototype.$toast = $toast
  Vue.prototype.$dialog = $dialog
}
67214
function install()
    {
        if (! $this->brew->hasInstalledPhp()) {
            $this->brew->ensureInstalled('php', [], $this->taps);
        }

        $this->files->ensureDirExists('/usr/local/var/log', user());

        $this->updateConfiguration();

        $this->restart();
    }
660715
def install(ctx, integrations, delete_after_install=False):
    """"""
    logger.debug("running command %s (%s)", ctx.command.name, ctx.params,
                 extra={"command": ctx.command.name, "params": ctx.params})

    home = ctx.obj["HOME"]
    integrations_path = os.path.join(home, INTEGRATIONS)

    installed_all_plugins = True
    for integration in integrations:
        try:
            plugin_utils.install_plugin(integration, INTEGRATION, integrations_path, register_integration)
        except exceptions.PluginAlreadyInstalled as exc:
            click.echo(exc)
            installed_all_plugins = False

    if not installed_all_plugins:
        raise ctx.exit(errno.EEXIST)