Removes Do Not Contact

        :param obj_id: int
        :param channel: str
        :return: dict|str
481851
def remove_dnc(self, obj_id, channel):
        
        response = self._client.session.post(
            '{url}/{id}/dnc/remove/{channel}'.format(
                url=self.endpoint_url, id=obj_id, channel=channel
            )
        )
        return self.process_response(response)
49043
def update_default_channels(sender, instance, created, **kwargs):
    
    if instance.default:
        Channel.objects.filter(default=True).exclude(
            channel_id=instance.channel_id
        ).update(default=False)
584013
def delete_message(self, id, remove):
        
        path = {}
        data = {}
        params = {}

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

        # REQUIRED - remove
        """Array of message ids to be deleted"""
        data["remove"] = remove

        self.logger.debug("POST /api/v1/conversations/{id}/remove_messages with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("POST", "/api/v1/conversations/{id}/remove_messages".format(**path), data=data, params=params, no_data=True)
535249
def delete(self, callback=None, errback=None):
        
        return self._rest.delete(self.data['id'], callback=callback, errback=errback)
1313249
async def remove_listener(self, channel, callback):
        """"""
        if self.is_closed():
            return
        if channel not in self._listeners:
            return
        if callback not in self._listeners[channel]:
            return
        self._listeners[channel].remove(callback)
        if not self._listeners[channel]:
            del self._listeners[channel]
            await self.fetch('UNLISTEN {}'.format(utils._quote_ident(channel)))
878959
private void handleGroupChannel(JsonNode channel) {
        long channelId = channel.get("id").asLong();

        api.getGroupChannelById(channelId).ifPresent(groupChannel -> {
            GroupChannelDeleteEvent event = new GroupChannelDeleteEventImpl(groupChannel);

            api.getEventDispatcher().dispatchGroupChannelDeleteEvent(
                    api, Collections.singleton(groupChannel), groupChannel.getMembers(), event);
            api.removeObjectListeners(GroupChannel.class, channelId);
            api.removeObjectListeners(VoiceChannel.class, channelId);
            api.removeObjectListeners(TextChannel.class, channelId);
            api.removeObjectListeners(Channel.class, channelId);
            api.forEachCachedMessageWhere(
                    msg -> msg.getChannel().getId() == groupChannel.getId(),
                    msg -> api.removeMessageFromCache(msg.getId())
            );
        });
    }
767005
def delete(self, id, id_name='id', **kwargs):
        
        response = self._new_response()
        if self._check_supported_op('delete', response):
            params = {'Key': {id_name: id}}
            self._call_ddb_method(self.table.delete_item, params, response)
            response.data = 'true'
        response.prepare()
        return response
695567
def _remove_session_callback(self, callback_obj, originator):
        ''' 

        '''
        try:
            callback_objs = [callback_obj]
            self._session_callbacks.remove(callback_obj)
            for cb, cb_objs in list(self._callback_objs_by_callable[originator].items()):
                try:
                    cb_objs.remove(callback_obj)
                    if not cb_objs:
                        del self._callback_objs_by_callable[originator][cb]
                except KeyError:
                    pass
        except KeyError:
            raise ValueError("callback already ran or was already removed, cannot be removed again")
        # emit event so the session is notified and can remove the callback
        for callback_obj in callback_objs:
            self._trigger_on_change(SessionCallbackRemoved(self, callback_obj))
461731
def remove(obj, kind):
    '''
    
    '''
    if not obj.get_badge(kind):
        api.abort(404, 'Badge does not exists')
    obj.remove_badge(kind)
    return '', 204
892523
def disconnect(self, func):
        """"""
        if id(self) not in _alleged_receivers:
            return
        l = _alleged_receivers[id(self)]
        try:
            l.remove(func)
        except ValueError:
            return
        if not l:
            del _alleged_receivers[id(self)]
865869
def remove(self,obj):
        
        relationship_table = self.params['relationship_table']
        with self.obj.backend.transaction(implicit = True):
            condition = and_(relationship_table.c[self.params['related_pk_field_name']] == obj.pk,
                             relationship_table.c[self.params['pk_field_name']] == self.obj.pk)
            self.obj.backend.connection.execute(delete(relationship_table).where(condition))
            self._queryset = None
1223053
def remove_contact(jid)
      bare = JID.new(jid).bare
      @roster.reject! {|c| c.jid.bare == bare }
    end
1010339
def remove_listener(self, registration_id):
        
        try:
            self._listeners.pop(registration_id)
            return True
        except KeyError:
            return False
896680
def delete(instance_id, profile=None, **kwargs):
    '''
    

    '''
    conn = _auth(profile, **kwargs)
    return conn.delete(instance_id)
1268079
def channels_remove_owner(self, room_id, user_id, **kwargs):
        """"""
        return self.__call_api_post('channels.removeOwner', roomId=room_id, userId=user_id, kwargs=kwargs)
1064215
def delete_record(self, record_id):
        
        self._delete(
            urljoin(self.base_url, "informationobjects/{}".format(record_id)),
            expected_response=204,
        )
        return {"status": "Deleted"}
798370
def remove(self, id):
        
        before_len = len(self.model.db)
        self.model.db = [t for t in self.model.db if t["id"] != id]
        if not self._batch.enable.is_set():
            self.model.save_db()
        return before_len - len(self.model.db)