Unregisters given action name.

        :param name: Action to register.
        :type name: unicode
        :return: Method success.
        :rtype: bool
168274
def unregister_action(self, name):
        

        name = self.__normalize_name(name)
        action = self.get_action(name)
        if not action:
            return False

        action.triggered.disconnect(self.__actions_signals_slots.pop(action))

        category = foundations.namespace.get_namespace(name)
        name = foundations.namespace.remove_namespace(name)
        self.remove_from_category(category, name)
        return True
1168573
def unregister(self, model=None):
        ''''''
        if model is not None:
            try:
                manager = self._registered_models.pop(model)
            except KeyError:
                return
            if self._registered_names.get(manager._meta.name) == manager:
                self._registered_names.pop(manager._meta.name)
            return [manager]
        else:
            managers = list(self._registered_models.values())
            self._registered_models.clear()
            return managers
685537
void unregisterWorkerMax(String name) {
        synchronized (workers) {
            Integer val = workers.remove(name);
            if (val != null) {
                total -= val;
            }
        }
    }
946457
def removeAction(self, action):
        
        action = action.split('#')
        del self.ACTIONS[int(action[1])]
        return True
92170
public void unregisterOperator(final String name) throws Exception
    {
        final String token = name.toLowerCase();
        if (!operatorMap.containsKey(token))
            throw new Exception("unknown operator: " + token);
        operatorMap.remove(token);
    }
740179
def service(name, action):
    
    if action == 'open':
        subprocess.check_output(['ufw', 'allow', str(name)],
                                universal_newlines=True)
    elif action == 'close':
        subprocess.check_output(['ufw', 'delete', 'allow', str(name)],
                                universal_newlines=True)
    else:
        raise UFWError(("'{}' not supported, use 'allow' "
                        "or 'delete'").format(action))
699226
public static void unregisterMbean(MBeanServer server, ObjectName name) {
        try {
            server.unregisterMBean(name);
        } catch(Exception e) {
            logger.error("Error unregistering mbean", e);
        }
    }
1067157
def unregister(self, model_or_iterable):
        
        if isinstance(model_or_iterable, ModelBase):
            model_or_iterable = [model_or_iterable]
        for model in model_or_iterable:
            # Check if the model is actually registered (``get_options_for_model``
            # throws an exception if it's not).
            self.get_options_for_model(model)
            # Invalidate all submodels options and forget about
            # the model itself.
            for desc, desc_opts in list(self._registry.items()):
                if not issubclass(desc, model):
                    continue
                if model != desc and desc_opts.registered:
                    # Allowing to unregister a base would necessitate
                    # repatching all submodels.
                    raise DescendantRegistered(
                        'You need to unregister descendant "%s" before'
                        ' unregistering its base "%s"' %
                        (desc.__name__, model.__name__))
                del self._registry[desc]
304919
def unregister_language(self, name):
        

        if not self.get_language(name):
            raise foundations.exceptions.ProgrammingError("{0} | '{1}' language isn't registered!".format(
                self.__class__.__name__, name))

        LOGGER.debug("> Unregistering '{0}' language.".format(name))

        for i, language in enumerate(self.__languages):
            if not language.name == name:
                continue

            del (self.__languages[i])
            self.sort_languages()
            return True
511176
def set_action_name(self, name):
        
        if self._open and name is not None:
            self._open[-1].name = name
            self.notify()
1280064
def removeRemoteByName(self, name: str) -> int:
        
        remote = self.getRemote(name)
        rid = remote.uid
        self.removeRemote(remote)
        return rid
736420
public void unregisterFunction(final String name) throws Exception
    {
        final String token = name.toLowerCase();
        if (!functionMap.containsKey(token))
            throw new Exception("unknown function: " + token);
        functionMap.remove(token);
    }
1277549
def destroy(name):
    '''
    
    '''
    node = show_instance(name, call='action')
    params = {'SUBID': node['SUBID']}
    result = _query('server/destroy', method='POST', decode=False, data=_urlencode(params))

    # The return of a destroy call is empty in the case of a success.
    # Errors are only indicated via HTTP status code. Status code 200
    # effetively therefore means "success".
    if result.get('body') == '' and result.get('text') == '':
        return True
    return result
754632
def deregister(cls, name: str) -> None:
        
        if name not in cls.available:
            raise ConnectionPluginNotRegistered(
                f"Connection {name!r} is not registered"
            )
        cls.available.pop(name)
178322
def remove(self, name):
        """"""
        self.gui.removeAction(self._actions_dict[name].qaction)
        del self._actions_dict[name]
        delattr(self, name)
601680
public function unregisterFunction($name) {
		if( isset($this->env->functions[$name]) )
			unset($this->env->functions[$name]);
	}
1157774
public static void unregisterMbean(ObjectName name) {
        try {
            ManagementFactory.getPlatformMBeanServer().unregisterMBean(name);
        } catch(Exception e) {
            logger.error("Error unregistering mbean", e);
        }
    }