DeletePublisherAsset.
        [Preview API] Delete publisher asset like logo
        :param str publisher_name: Internal name of the publisher
        :param str asset_type: Type of asset. Default value is 'logo'.
353815
def delete_publisher_asset(self, publisher_name, asset_type=None):
        
        route_values = {}
        if publisher_name is not None:
            route_values['publisherName'] = self._serialize.url('publisher_name', publisher_name, 'str')
        query_parameters = {}
        if asset_type is not None:
            query_parameters['assetType'] = self._serialize.query('asset_type', asset_type, 'str')
        self._send(http_method='DELETE',
                   location_id='21143299-34f9-4c62-8ca8-53da691192f9',
                   version='5.1-preview.1',
                   route_values=route_values,
                   query_parameters=query_parameters)
378568
def delete_mapping(self, index, doc_type):
        
        path = make_path(index, doc_type)
        return self.conn._send_request('DELETE', path)
678962
def remove_plugin(self, plugin_type, plugin_name):
        
        for p in self.dock_json[plugin_type]:
            if p.get('name') == plugin_name:
                self.dock_json[plugin_type].remove(p)
                break
956142
def remove_project_avatar(self, project_id):
        
        route_values = {}
        if project_id is not None:
            route_values['projectId'] = self._serialize.url('project_id', project_id, 'str')
        self._send(http_method='DELETE',
                   location_id='54b2a2a0-859b-4d05-827c-ec4c862f641a',
                   version='5.1-preview.1',
                   route_values=route_values)
442754
def delete(self):
        """"""

        with self.draft_context():
            draft = self.one(Q._uid == self._uid)
            if draft:
                super(PublisherFrame, draft).delete()

        with self.published_context():
            published = self.one(Q._uid == self._uid)
            if published:
                super(PublisherFrame, published).delete()
248707
def unpublish(self):
        
        if self.is_draft and self.publishing_linked:
            publishing_signals.publishing_pre_unpublish.send(
                sender=type(self), instance=self)
            # Unlink draft and published copies then delete published.
            # NOTE: This indirect dance is necessary to avoid triggering
            # unwanted MPTT tree structure updates via `delete`.
            type(self.publishing_linked).objects \
                .filter(pk=self.publishing_linked.pk) \
                .delete()  # Instead of self.publishing_linked.delete()
            # NOTE: We update and save the object *after* deleting the
            # published version, in case the `save()` method does some
            # validation that breaks when unlinked published objects exist.
            self.publishing_linked = None
            self.publishing_published_at = None

            # Save the draft to remove its relationship with the published copy
            publishing_signals.publishing_unpublish_save_draft.send(
                sender=type(self), instance=self)

            publishing_signals.publishing_post_unpublish.send(
                sender=type(self), instance=self)
340922
def create_draft_for_edit_extension(self, publisher_name, extension_name):
        
        route_values = {}
        if publisher_name is not None:
            route_values['publisherName'] = self._serialize.url('publisher_name', publisher_name, 'str')
        if extension_name is not None:
            route_values['extensionName'] = self._serialize.url('extension_name', extension_name, 'str')
        response = self._send(http_method='POST',
                              location_id='02b33873-4e61-496e-83a2-59d1df46b7d8',
                              version='5.0-preview.1',
                              route_values=route_values)
        return self._deserialize('ExtensionDraft', response)
236147
def del_feature(self, pr_name):
        
        if hasattr(self, pr_name):
            delattr(self, pr_name)
            self.features.remove(pr_name)
126968
def get_asset_from_edit_extension_draft(self, publisher_name, draft_id, asset_type, extension_name, **kwargs):
        
        route_values = {}
        if publisher_name is not None:
            route_values['publisherName'] = self._serialize.url('publisher_name', publisher_name, 'str')
        if draft_id is not None:
            route_values['draftId'] = self._serialize.url('draft_id', draft_id, 'str')
        if asset_type is not None:
            route_values['assetType'] = self._serialize.url('asset_type', asset_type, 'str')
        query_parameters = {}
        if extension_name is not None:
            query_parameters['extensionName'] = self._serialize.query('extension_name', extension_name, 'str')
        response = self._send(http_method='GET',
                              location_id='88c0b1c8-b4f1-498a-9b2a-8446ef9f32e7',
                              version='5.0-preview.1',
                              route_values=route_values,
                              query_parameters=query_parameters,
                              accept_media_type='application/octet-stream')
        if "callback" in kwargs:
            callback = kwargs["callback"]
        else:
            callback = None
        return self._client.stream_download(response, callback=callback)
867414
def delete_image(self, image_id):

        '''
            
        '''

        title = '%s.delete_image' % self.__class__.__name__

    # validate inputs
        input_fields = {
            'image_id': image_id
        }
        for key, value in input_fields.items():
            object_title = '%s(%s=%s)' % (title, key, str(value))
            self.fields.validate(value, '.%s' % key, object_title)

    # report query
        self.iam.printer('Removing image %s from AWS region %s.' % (image_id, self.iam.region_name))

    # retrieve state
        old_state = self.check_image_state(image_id)

    # discover snapshot id and tags associated with instance id
        image_details = self.read_image(image_id)
        tag_list = image_details['tags']
        snapshot_id = image_details['snapshot_id']

    # remove tags from instance
        try:
            delete_kwargs = {
                'Resources': [ image_id ],
                'Tags': self.iam.prepare(tag_list)
            }
            self.connection.delete_tags(**delete_kwargs)
            self.iam.printer('Tags have been deleted from %s.' % image_id)
        except:
            raise AWSConnectionError(title)

    # deregister image
        try:
            self.connection.deregister_image(
                ImageId=image_id
            )
        except:
            raise AWSConnectionError(title)
        self.iam.printer('Image %s has been deregistered.' % image_id)

    # delete snapshot
        try:
            response = self.connection.delete_snapshot(
                SnapshotId=snapshot_id
            )
        except:
            raise AWSConnectionError(title)
        self.iam.printer('Snapshot %s associated with image %s has been deleted.' % (snapshot_id, image_id))

        return response
1357456
def delete(type, name)
      resource_class = parse_type(type)
      client_setup
      matches = resource_class.find_by(@client, name: name)
      fail_nice('Not Found', 2) if matches.empty?
      resource = matches.first
      return unless options['force'] || agree("Delete '#{name}'? [Y/N] ")
      begin
        resource.delete
        puts 'Deleted Successfully!'
      rescue StandardError => e
        fail_nice "Failed to delete #{resource.class.name.split('::').last} '#{name}': #{e}"
      end
    end
637467
def clear_title(self):
        
        # Implemented from template for osid.repository.AssetForm.clear_title_template
        if (self.get_title_metadata().is_read_only() or
                self.get_title_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['title'] = dict(self._title_default)
1039634
def unregister_publisher(topic)
      code, message, val = @proxy.unregisterPublisher(@caller_id,
                                                      topic,
                                                      @slave_uri)
      if code == 1
        return val
      elsif code == 0
        puts message
        return true
      else
        raise message
      end
      return false
    end
630214
def del_character(self, name):
        
        self.query.del_character(name)
        self.del_graph(name)
        del self.character[name]
668482
def delete_connection(api)
      @subscribers.delete_if {|x| x.api == api}
      @publishers.delete_if {|x| x.api == api}
      @services.delete_if {|x| x.api == api}
    end
448997
def delete_peer(self, name, peer_type="REPLICATION"):
    
    params = self._get_peer_type_param(peer_type)
    return self._delete("peers/" + name, ApiCmPeer, params=params, api_version=3)
1119348
def create_publisher(self, publisher):
        
        content = self._serialize.body(publisher, 'Publisher')
        response = self._send(http_method='POST',
                              location_id='4ddec66a-e4f6-4f5d-999e-9e77710d7ff4',
                              version='5.0-preview.1',
                              content=content)
        return self._deserialize('Publisher', response)