Delete an identity from SortingHat.

        :param sh_db: SortingHat database
        :param ident_id: identity identifier
551118
def remove_identity(cls, sh_db, ident_id):
        
        success = False
        try:
            api.delete_identity(sh_db, ident_id)
            logger.debug("Identity %s deleted", ident_id)
            success = True
        except Exception as e:
            logger.debug("Identity not deleted due to %s", str(e))

        return success
326673
def _delete_record(self, identifier=None, rtype=None, name=None, content=None):
        
        ids = []

        if identifier:
            ids.append(identifier)
        elif not identifier and rtype and name:
            records = self._list_records(rtype, name, content)
            if records:
                ids = [record["id"] for record in records]

        if ids:
            LOGGER.debug("delete_records: %s", ids)
            with localzone.manage(self.filename, self.origin, autosave=True) as zone:
                for hashid in ids:
                    zone.remove_record(hashid)  # pylint: disable=no-member
                    LOGGER.debug("delete_record: %s", hashid)

        return True
106539
public void remove(Identity oid)
    {
        //processQueue();
        if(oid != null)
        {
            removeTracedIdentity(oid);
            objectTable.remove(buildKey(oid));
            if(log.isDebugEnabled()) log.debug("Remove object " + oid);
        }
    }
341632
def delete_credential(self, identifier, credential_id=None):
        
        credential = {
            'id': credential_id
        }

        return self.client.call('SoftLayer_Network_Storage_Hub_Cleversafe_Account', 'credentialDelete',
                                credential, id=identifier)
73545
def removeID(self, idVal):
        
        for i in self:
            if i.id == idVal:
                self._collection.remove(i)
                return
        raise KeyError("A Record with the ID '{}' was not found in the RecordCollection: '{}'.".format(idVal, self))
380737
def delete(self, account_id, user_id):
        
        return self.connection.delete('account/access', account_id=account_id, user_id=user_id)
1018720
def remove(cls, id):
        

        api = Client.instance().api
        api.index(id).delete()
814478
public void setIdentityIdsToDelete(java.util.Collection<String> identityIdsToDelete) {
        if (identityIdsToDelete == null) {
            this.identityIdsToDelete = null;
            return;
        }

        this.identityIdsToDelete = new java.util.ArrayList<String>(identityIdsToDelete);
    }
211904
def delete(self, id: int):
        
        assert isinstance(id, int)

        self.open_session()
        to_delete = self.get(id)
        self.session.delete(to_delete)
        self.save()
88385
def remove_profile(self, profile=None):
        
        with self.db:
            return self.db.remove(self.query.profile == profile)
1366840
def purge_one(calc_id, user):
    
    filename = os.path.join(datadir, 'calc_%s.hdf5' % calc_id)
    err = dbcmd('del_calc', calc_id, user)
    if err:
        print(err)
    elif os.path.exists(filename):  # not removed yet
        os.remove(filename)
        print('Removed %s' % filename)
115779
static function removeIdentity(\Db\Connection $db, User $user, $openid) {
    if (!$user) {
      throw new \InvalidArgumentException("No user provided.");
    }

    $q = $db->prepare("DELETE FROM user_openid_identities WHERE user_id=? AND identity=? LIMIT 1");
    return $q->execute(array($user->getId(), $openid));
  }
950003
def remove(self, cluster_id):
        
        cluster = self._storage.pop(cluster_id)
        cluster.cleanup()
331773
def delete(self, id):
        
        self.conn.cursor().execute("DELETE FROM WeRoBot WHERE id=%s", (id, ))
        self.conn.commit()
248282
def delete_one(self, id_):
                
        url = "https://api.knackhq.com/v1/objects/%s/records/%s" % (
            self.key, id_)
        res = self.delete(url)
        return res
1210078
def delete_dagobah(self, dagobah_id):
        

        rec = self.dagobah_coll.find_one({'_id': dagobah_id})
        for job in rec.get('jobs', []):
            if 'job_id' in job:
                self.delete_job(job['job_id'])
        self.log_coll.remove({'parent_id': dagobah_id})
        self.dagobah_coll.remove({'_id': dagobah_id})
94117
public void remove(Identity oid)
    {
        try
        {
            jcsCache.remove(oid.toString());
        }
        catch (CacheException e)
        {
            throw new RuntimeCacheException(e.getMessage());
        }
    }