Remove an object from the bucket.

        :param bucket_name: Bucket of object to remove
        :param object_name: Name of object to remove
        :return: None
161162
def remove_object(self, bucket_name, object_name):
        
        is_valid_bucket_name(bucket_name)
        is_non_empty_string(object_name)

        # No reason to store successful response, for errors
        # relevant exceptions are thrown.
        self._url_open('DELETE', bucket_name=bucket_name,
                       object_name=object_name)
276522
def list_objects(self, bucket_name=None, **kwargs):
        
        if not bucket_name: bucket_name = self.bucket_name
        return self.client.list_objects(Bucket=bucket_name, **kwargs)
1179189
def remove_object(self, name):
        
        if name not in self._object_map:
            raise RuntimeError('No object with name {} is registered.'.format(name))

        for fn_name in list(self._function_map.keys()):
            if fn_name.startswith(name + '.') or fn_name.startswith(name + ':'):
                self._remove_function(fn_name)

        del self._object_map[name]
74418
def delete_cloud_obj(self, cloud_obj):
        
        self._connection.delete_object(
            container=self.container_name,
            obj=cloud_obj,
        )
818153
def download_object(self, instance, bucket_name, object_name):
        
        url = '/buckets/{}/{}/{}'.format(instance, bucket_name, object_name)
        response = self._client.get_proto(path=url)
        return response.content
1094469
def remove_field(self, name):
        
        field = self.get_field(name)
        if field:
            predicat = lambda field: field.get('name') != name
            self.__current_descriptor['fields'] = filter(
                predicat, self.__current_descriptor['fields'])
            self.__build()
        return field
789870
def clean_buckets(self, hash_name):
        
        bucket_keys = self._iter_bucket_keys(hash_name)
        self.redis_object.delete(*bucket_keys)
704582
def project_remove_objects(object_id, input_params={}, always_retry=False, **kwargs):
    
    return DXHTTPRequest('/%s/removeObjects' % object_id, input_params, always_retry=always_retry, **kwargs)
876301
def remove_from_cluster(self, name, *args):
        
        cluster = self.get_cluster(name=name)
        attrs_ = cluster['cluster']
        for a in args:
            del attrs_[a]
387609
def delete_if_exists(self, **kwargs):
        
        try:
            self.get(**kwargs).blocking_delete()
            return True
        except ObjectDoesNotExist:
            return False
1354438
def delete_object(self, obj):
        
        session = self.get_db_session()
        session.delete(obj)
        session.commit()
333120
def remove(self):
        
        ''' 
            
        '''
    
        title = '%s.remove' % self.__class__.__name__
    
    # request bucket delete 
        self.s3.delete_bucket(self.bucket_name)

    # return confirmation
        exit_msg = '%s collection has been removed from S3.' % self.bucket_name
        return exit_msg
2155
def head_object(self, bucket, object_name):
        
        details = self._details(
            method=b"HEAD",
            url_context=self._url_context(bucket=bucket, object_name=object_name),
        )
        d = self._submit(self._query_factory(details))
        d.addCallback(lambda (response, body): _to_dict(response.responseHeaders))
        return d
1241757
public static void unregister(MBeanServer server, String object_name) throws Exception {
        Set<ObjectName> mbeans = server.queryNames(new ObjectName(object_name), null);
        if(mbeans != null)
            for (ObjectName name: mbeans)
                server.unregisterMBean(name);
    }
545875
def container_remove_objects(object_id, input_params={}, always_retry=False, **kwargs):
    
    return DXHTTPRequest('/%s/removeObjects' % object_id, input_params, always_retry=always_retry, **kwargs)
879055
def remove(cls, name):
        

        client = Client.instance()

        new_current_database = None

        if client.database != name:
            new_current_database = name

        # Deletions are only possible from the system database
        client.set_database(name=SYSTEM_DATABASE)

        api = client.api
        api.database(name).delete()

        if new_current_database:
            client.set_database(name=new_current_database)
730400
def delete(self, bucket: str, key: str):
        
        bucket_obj = self._ensure_bucket_loaded(bucket)
        try:
            bucket_obj.delete_blob(key)
        except NotFound:
            return False