Hide a tool so that it is not exposed in the suite.

        Args:
            context_name (str): Context containing the tool.
            tool_name (str): Name of tool to hide.
516675
def hide_tool(self, context_name, tool_name):
        
        data = self._context(context_name)
        hidden_tools = data["hidden_tools"]
        if tool_name not in hidden_tools:
            self._validate_tool(context_name, tool_name)
            hidden_tools.add(tool_name)
            self._flush_tools()
109850
def name(self):
        
        python = self._python
        if self._python.startswith('pypy'):
            # get_env_name adds py-prefix
            python = python[2:]
        return environment.get_env_name(self.tool_name, python, self._requirements)
412707
def hide(name)
      base_fields[name] = base_fields[name].dup
      base_fields[name].widget = Widgets::HiddenInput.new
    end
1215039
public String hidden (String name, Object defaultValue)
    {
        return fixedHidden(name, getValue(name, defaultValue));
    }
1316716
def remove_snippet_client(self, name):
        
        if name not in self._snippet_clients:
            raise Error(self._device, MISSING_SNIPPET_CLIENT_MSG % name)
        client = self._snippet_clients.pop(name)
        client.stop_app()
934202
def remove_plugin(self, phase, name, reason=None):
        
        for p in self.template[phase]:
            if p.get('name') == name:
                self.template[phase].remove(p)
                if reason:
                    logger.info('Removing {}:{}, {}'.format(phase, name, reason))
                break
144526
def unalias_tool(self, context_name, tool_name):
        
        data = self._context(context_name)
        aliases = data["tool_aliases"]
        if tool_name in aliases:
            del aliases[tool_name]
            self._flush_tools()
266009
public function unhideField($field_name)
    {
        if (($key = array_search($field_name, $this->hiddenFields)) !== false) {
            unset($this->hiddenFields[$key]);
        }
    }
1080444
def subset_hook_caller(self, name, remove_plugins):
        
        orig = getattr(self.hook, name)
        plugins_to_remove = [plug for plug in remove_plugins if hasattr(plug, name)]
        if plugins_to_remove:
            hc = _HookCaller(
                orig.name, orig._hookexec, orig.spec.namespace, orig.spec.opts
            )
            for hookimpl in orig.get_hookimpls():
                plugin = hookimpl.plugin
                if plugin not in plugins_to_remove:
                    hc._add_hookimpl(hookimpl)
                    # we also keep track of this hook caller so it
                    # gets properly removed on plugin unregistration
                    self._plugin2hookcallers.setdefault(plugin, []).append(hc)
            return hc
        return orig
900914
def remove_hook(self, key_name, hook_name):
        """"""
        kf = self.dct[key_name]
        if 'hooks' in kf:
            if hook_name in kf['hooks']:
                return kf['hooks'].pop(hook_name)
1273310
public static void hideKeyboard(Context context, View target) {
        if (context == null || target == null) {
            return;
        }

        InputMethodManager imm = getInputMethodManager(context);
        imm.hideSoftInputFromWindow(target.getWindowToken(), 0);
    }
165630
def disable_plugin(self, name):
        
        url = self._url('/plugins/{0}/disable', name)
        res = self._post(url)
        self._raise_for_status(res)
        return True
135781
def delete_contexts(self, context_id_list):
        
        for c_id in context_id_list:
            if c_id in self._contexts:
                del self._contexts[c_id]
112107
def get_tool(name): 
    
    tool = name.lower()
    if tool not in __tools__:
        raise ValueError("Tool {0} not found!\n".format(name))

    t = __tools__[tool]()

    if not t.is_installed():
        sys.stderr.write("Tool {0} not installed!\n".format(tool))

    if not t.is_configured():
        sys.stderr.write("Tool {0} not configured!\n".format(tool))

    return t
1183652
public static void setVisible(VisualizerContext context, VisualizationTask task, boolean visibility) {
    // Hide other tools
    if(visibility && task.isTool()) {
      Hierarchy<Object> vistree = context.getVisHierarchy();
      for(It<VisualizationTask> iter2 = vistree.iterAll().filter(VisualizationTask.class); iter2.valid(); iter2.advance()) {
        VisualizationTask other = iter2.get();
        if(other != task && other.isTool() && other.isVisible()) {
          context.visChanged(other.visibility(false));
        }
      }
    }
    context.visChanged(task.visibility(visibility));
  }
97972
def remove_context(self, name):
        
        context = self.get_context(name)
        contexts = self.get_contexts()
        contexts.remove(context)
272180
def remove_private_obfuscation(self):
    
    classname = self.__class__.__name__
    attrlist = [attr for attr in dir(self) if attr.startswith('_' + classname + '__')]
    for attr in attrlist:
        method = getattr(self, attr)
        truename = attr.replace('_' + classname + '__', '__')
        setattr(self, truename, method)