Remove hosts/host_vars/group_vars and returns None.

        :returns: None
764083
def _remove_vars(self):
        
        for name in ("hosts", "group_vars", "host_vars"):
            d = os.path.join(self.inventory_directory, name)
            if os.path.islink(d) or os.path.isfile(d):
                os.unlink(d)
            elif os.path.isdir(d):
                shutil.rmtree(d)
1287692
def remove_usage_rights_groups(self, group_id, file_ids, folder_ids=None):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - group_id
        """ID"""
        path["group_id"] = group_id

        # REQUIRED - file_ids
        """List of ids of files to remove associated usage rights from."""
        params["file_ids"] = file_ids

        # OPTIONAL - folder_ids
        """List of ids of folders. Usage rights will be removed from all files in these folders."""
        if folder_ids is not None:
            params["folder_ids"] = folder_ids

        self.logger.debug("DELETE /api/v1/groups/{group_id}/usage_rights with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("DELETE", "/api/v1/groups/{group_id}/usage_rights".format(**path), data=data, params=params, no_data=True)
740813
def delete(self, *args, **kwargs):
        '''  '''
        hosted_zone = route53_backend.get_hosted_zone_by_name(
            self.hosted_zone_name)
        if not hosted_zone:
            hosted_zone = route53_backend.get_hosted_zone(self.hosted_zone_id)
        hosted_zone.delete_rrset_by_name(self.name)
1028263
def delete(resource_group_name, policy_name, custom_headers:nil)
      response = delete_async(resource_group_name, policy_name, custom_headers:custom_headers).value!
      nil
    end
490874
def delete_host_from_segment(ipaddress, networkaddress, auth, url):
    '''

    '''
    host_id = get_host_id(ipaddress, networkaddress, auth, url)
    remove_scope_ip(host_id, auth.creds, auth.url)
553295
def deleteAllGroups(server):
    '''
    
    '''

    try:
        client, key = _get_session(server)
    except Exception as exc:
        err_msg = 'Exception raised when connecting to spacewalk server ({0}): {1}'.format(server, exc)
        log.error(err_msg)
        return {'Error': err_msg}

    groups = client.systemgroup.listAllGroups(key)

    deleted_groups = []
    failed_groups = []

    for group in groups:
        if client.systemgroup.delete(key, group['name']) == 1:
            deleted_groups.append(group['name'])
        else:
            failed_groups.append(group['name'])

    ret = {'deleted': deleted_groups}
    if failed_groups:
        ret['failed'] = failed_groups
    return ret
383118
def destroy
    @config_var = ConfigVar.where(name: params[:name]).first
    @config_var.destroy

    respond_to do |format|
      format.html { redirect_to(config_vars_url) }
    end
  end
1111629
def remove_security_group(self, name):
        
        for group in self.security_groups:
            if group.isc_name == name:
                group.delete()
1351008
def removeSettingsGroup(groupName, settings=None):
    
    logger.debug("Removing settings group: {}".format(groupName))
    settings = QtCore.QSettings() if settings is None else settings
    settings.remove(groupName)
1347686
def hosts_in_group(self, groupname):
        
        result = []
        for hostname, hostinfo in self.hosts.items():
            if groupname == 'all':
                result.append(hostname)
            elif 'groups' in hostinfo:
                if groupname in hostinfo['groups']:
                    result.append(hostname)
            else:
                hostinfo['groups'] = [groupname]
        return result
593582
def delete(self):
        
        key = 'https://plex.tv/devices/%s.xml' % self.id
        self._server.query(key, self._server._session.delete)
1048510
def clear_group(self):
        
        # Implemented from template for osid.resource.ResourceForm.clear_group_template
        if (self.get_group_metadata().is_read_only() or
                self.get_group_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['group'] = self._group_default
1119666
def delete_group(group_id, tasks=False, cached=Conf.CACHED):
    
    if cached:
        return delete_group_cached(group_id)
    return Task.delete_group(group_id, tasks)
1111449
def remove_group(self, groupname):
        
        # implementation based on
        # https://docs.atlassian.com/jira/REST/ondemand/#d2e5173
        url = self._options['server'] + '/rest/api/latest/group'
        x = {'groupname': groupname}
        self._session.delete(url, params=x)
        return True
1248510
def remove_from_known_hosts(self, hosts, known_hosts=DEFAULT_KNOWN_HOSTS, dry=False):
        
        for host in hosts:
            logger.info('[%s] Removing the remote host SSH public key from [%s]...', host.hostname, known_hosts)
            cmd = ['ssh-keygen', '-f', known_hosts, '-R', host.hostname]
            logger.debug('Call: %s', ' '.join(cmd))
            if not dry:
                try:
                    subprocess.check_call(cmd)
                except subprocess.CalledProcessError as ex:
                    logger.error(format_error(format_exception(ex)))
880511
def delete_variable_group(self, project, group_id):
        
        route_values = {}
        if project is not None:
            route_values['project'] = self._serialize.url('project', project, 'str')
        if group_id is not None:
            route_values['groupId'] = self._serialize.url('group_id', group_id, 'int')
        self._send(http_method='DELETE',
                   location_id='f5b09dd5-9d54-45a1-8b5a-1c8287d634cc',
                   version='5.1-preview.1',
                   route_values=route_values)
831286
def _parse_group(self, group_name, group):
        
        if type(group) == dict:
            # Example:
            #     {
            #       "mgmt": {
            #         "hosts": [ "mgmt01", "mgmt02" ],
            #         "vars": {
            #           "eth0": {
            #             "onboot": "yes",
            #             "nm_controlled": "no"
            #           }
            #         }
            #       }
            #     }
            #
            hostnames_in_group = set()

            # Group member with hosts and variable definitions.
            for hostname in group.get('hosts', []):
                self._get_host(hostname)['groups'].add(group_name)
                hostnames_in_group.add(hostname)
            # Apply variables to all hosts in group
            for var_key, var_val in group.get('vars', {}).items():
                for hostname in hostnames_in_group:
                    self._get_host(hostname)['hostvars'][var_key] = var_val
        elif type(group) == list:
            # List of hostnames for this group
            for hostname in group:
                self._get_host(hostname)['groups'].add(group_name)
        else:
            self.log.warning("Invalid element found in dynamic inventory output: {0}".format(type(group)))