Delete namespace with specific name
        :param name: str, namespace to delete
        :return: None
540720
def delete_namespace(self, name):
        
        self.core_api.delete_namespace(name, client.V1DeleteOptions())

        logger.info("Deleting namespace: %s", name)
860953
def unmap_namespace(self, plain_target_ns):
        
        # Return the same namespace if there are no included namespaces.
        if not self._regex_map and not self._plain:
            return plain_target_ns

        src_name_set = self._reverse_plain.get(plain_target_ns)
        if src_name_set:
            # Return the first (and only) item in the set
            for src_name in src_name_set:
                return src_name
        # The target namespace could also exist in the wildcard namespaces
        for _, namespace in self._regex_map:
            original_name = match_replace_regex(
                namespace_to_regex(namespace.dest_name),
                plain_target_ns,
                namespace.source_name,
            )
            if original_name:
                return original_name
        return None
883294
def delete(self, namespace, key):
        
        if self.key_exists(namespace, key):
            obj = db.ConfigItem.find_one(
                ConfigItem.namespace_prefix == namespace,
                ConfigItem.key == key
            )

            del self.__data[namespace][key]

            db.session.delete(obj)
            db.session.commit()
        else:
            raise KeyError('{}/{}'.format(namespace, key))
1127530
def filter_alias_create_namespace(namespace):
    
    def filter_string(s):
        return ' '.join(s.strip().split())

    namespace.alias_name = filter_string(namespace.alias_name)
    namespace.alias_command = filter_string(namespace.alias_command)
    return namespace
90587
def delete_service(self, name):
    
    return services.delete_service(self._get_resource_root(), name, self.name)
1027903
def p_namespace(p):
    
    global NAMESPACE

    NAMESPACE = normalize_namespace(p[2])
    __DEBUG__('Setting namespace to ' + (NAMESPACE.rstrip(DOT) or DOT), level=1)
1043019
def delete(self, name):
        
        try:
            super(StaticCompilerFileStorage, self).delete(name)
        except OSError, e:
            if e.errno != errno.ENOENT:
                raise
364041
async def delete(self, *names):
        
        count = 0

        for arg in names:
            count += await self.execute_command('DEL', arg)

        return count
983445
def delete_namespace(namespace)
      raise(TriplestoreAdapter::TriplestoreException, "delete_namespace received blank namespace") if namespace.empty?
      request = Net::HTTP::Delete.new("#{build_url}/blazegraph/namespace/#{namespace}")
      @http.request(@uri, request)
      return true
    end
813357
def delete(name, force=False):
    '''
    
    '''
    ret = {}

    if name not in list_nictags():
        return True

    cmd = 'nictagadm delete {0}{1}'.format("-f " if force else "", name)
    res = __salt__['cmd.run_all'](cmd)

    if res['retcode'] == 0:
        return True
    else:
        return {'Error': 'failed to delete nictag.' if 'stderr' not in res and res['stderr'] == '' else res['stderr']}
578732
public void deleteNamespace(String namespaceId) {

        DeleteNamespaceRequest deleteNamespaceRequest = new DeleteNamespaceRequest().withId(namespaceId);
        getDiscoveryClient().deleteNamespace(deleteNamespaceRequest);

    }
438263
def _replace_spaces(self, name: str) -> str:
        
        if self.replace_spaces:
            return name.strip().replace(' ', str(self.replace_spaces_with))
        return name
747020
def delete_namespace(self):
        '''

        '''
        conn = redis.Redis(connection_pool=self.pool)
        keys = conn.keys("%s*" % self._namespace_str)
        for i in xrange(0, len(keys), 10000):
            conn.delete(*keys[i:i+10000])
        logger.debug('tearing down %r', self._namespace_str)
97972
def remove_context(self, name):
        
        context = self.get_context(name)
        contexts = self.get_contexts()
        contexts.remove(context)
1242739
def do_delete(self, args):
        ''''''
        namespace = self.config['namespace']
        if not args.assume_yes:
            response = raw_input('Delete everything in {0!r}?  Enter namespace: '
                                 .format(namespace))
            if response != namespace:
                self.stdout.write('not deleting anything\n')
                return
        self.stdout.write('deleting namespace {0!r}\n'.format(namespace))
        self.task_master.clear()
1171518
def get_available_name(self, name):
        
        if self.exists(name):
            self.delete(name)
        return name
1356504
def skip_storing_namespace(self, namespace: Optional[str]) -> bool:
        
        return (
            namespace is not None and
            namespace in self.namespace_url and
            self.namespace_url[namespace] in self.uncached_namespaces
        )