Deletes an existing keypair with given ACCESSKEY.
765733
async def delete(cls, access_key: str):
        
        q = 'mutation($access_key: String!) {' \
            '  delete_keypair(access_key: $access_key) {' \
            '    ok msg' \
            '  }' \
            '}'
        variables = {
            'access_key': access_key,
        }
        rqst = Request(cls.session, 'POST', '/admin/graphql')
        rqst.set_json({
            'query': q,
            'variables': variables,
        })
        async with rqst.fetch() as resp:
            data = await resp.json()
            return data['delete_keypair']
166738
public static void delete( Key key ) { 
    Value val = DKV.get(key);
    if( val==null ) return;
    ((Lockable)val.get()).delete();
  }
596792
public int delete(CMAApiKey key) {
    assertNotNull(key, "key");
    final String space = getSpaceIdOrThrow(key, "key");
    final String id = getResourceIdOrThrow(key, "key");

    return service.delete(space, id).blockingFirst().code();
  }
538434
def remove(self, key):
        

        data = self._load_file()
        del data[key]
        self._save_file(data)
753927
def delete_entry(self, key):
        """"""
        pipe = self.client.pipeline()
        pipe.srem(self.keys_container, key)
        pipe.delete(key)
        pipe.execute()
1257699
def delete(key)
      file = filename key
      File.delete file if File.exist? file
    end
896068
def remove_key(self, key):
        """"""
        try:
            self._own_keys.discard(key)
            if self._parent and self._parent.has_key(key):
                self._container[key] = self._parent[key]
            else:
                del self._container[key]
        except KeyError:
            pass
1007783
def remove(self, key):
        
        payload = {
            key: {
                '__op': 'Delete'
                }
            }
        self.__class__.PUT(self._absolute_url, **payload)
        del self.__dict__[key]
925814
def clear_lock(self, key):
        
        lock_path = self._get_lock_path(key)
        os.remove(lock_path)
1025509
def forget(self, key):
        
        return bool(self._redis.delete(self._prefix + key))
1083083
def delete(key, options = {})
      custom_params = options[:dc] ? use_named_parameter('dc', options[:dc]) : nil
      ret = send_delete_request(@conn, ["/v1/query/#{key}"], options, custom_params)
      ret.status == 200
    end
1339200
public boolean removeImportedKey(ECKey key) {
        checkNotNull(key);
        checkArgument(!(key instanceof DeterministicKey));
        return basic.removeKey(key);
    }
752365
def delete(self, key):
        """"""
        if not self.debug:
            self.database.delete(self.make_key(key))
998964
function remove(keyId, callback) {
    commons.del(format('/%s/keys/%s', deis.version, keyId), callback);
  }
192488
def _remove_existing(self):
        
        for key in self._keys:
            if key in os.environ:
                LOG.debug('%r: removing old key %r', self, key)
                del os.environ[key]
        self._keys = []
1187306
def delete(self, *args, **kwargs):
        """"""
        cache_key = self.make_key(args, kwargs)
        with self._cache_lock:
            try:
                del self._cache[cache_key]
            except KeyError:
                pass
668406
def delete(key, options = {})
      info = Utils.build_info(key, options)

      command "delete-generic-password",
        "-a", info[:account_name],
        "-s", info[:service_name],
        "-l", info[:label],
        "-D", info[:kind],
        "-C", info[:type]
    end