Permanently delete this blob from Blobstore.

    Args:
      **options: Options for create_rpc().
504092
def delete(self, **options):
    
    fut = delete_async(self.key(), **options)
    fut.get_result()
112358
def delete(self, endpoint, **kwargs):
        
        kwargs.update(self.kwargs.copy())
        response = requests.delete(self.make_url(endpoint), **kwargs)
        return _decode_response(response)
257860
def delete_and_rm_options(*args, **kwargs):
    

    def inner_decorator(f, supports_batch=True, default_enable_globs=False):
        f = click.option(
            "--recursive", "-r", is_flag=True, help="Recursively delete dirs"
        )(f)
        f = click.option(
            "--ignore-missing",
            "-f",
            is_flag=True,
            help="Don't throw errors if the file or dir is absent",
        )(f)
        f = click.option(
            "--star-silent",
            "--unsafe",
            "star_silent",
            is_flag=True,
            help=(
                'Don\'t prompt when the trailing character is a "*".'
                + (" Implicit in --batch" if supports_batch else "")
            ),
        )(f)
        f = click.option(
            "--enable-globs/--no-enable-globs",
            is_flag=True,
            default=default_enable_globs,
            show_default=True,
            help=(
                "Enable expansion of *, ?, and [ ] characters in the last "
                "component of file paths, unless they are escaped with "
                "a preceeding backslash, \\"
            ),
        )(f)
        if supports_batch:
            f = click.option(
                "--batch",
                is_flag=True,
                help=(
                    "Accept a batch of paths on stdin (i.e. run in "
                    "batchmode). Uses ENDPOINT_ID as passed on the "
                    "commandline. Any commandline PATH given will be used "
                    "as a prefix to all paths given"
                ),
            )(f)
        return f

    return detect_and_decorate(inner_decorator, args, kwargs)
629472
def delete(options = {})
      options = options.merge(
        user_name: @user_name,
        policy_name: @name
      )
      resp = @client.delete_user_policy(options)
      resp.data
    end
42350
def delete(options = {})
      options = options.merge(
        account_id: @account_id,
        vault_name: @vault_name,
        archive_id: @id
      )
      resp = @client.delete_archive(options)
      resp.data
    end
1105845
def delete(self, save=True):
        
        for thumb in self.field.thumbs:
            thumb_name, thumb_options = thumb
            thumb_filename = self._calc_thumb_filename(thumb_name)
            self.storage.delete(thumb_filename)

        super(ImageWithThumbsFieldFile, self).delete(save)
158240
def remove(self):
        
        lib.gp_camera_file_delete(self._cam._cam, self.directory.path.encode(),
                                  self.name.encode(), self._cam._ctx)
931525
def delete(options = {})
      options = options.merge(queue_url: @url)
      resp = @client.delete_queue(options)
      resp.data
    end
308843
def delete(self, force_drop=False, *args, **kwargs):
        
        self._drop_schema(force_drop)
        super().delete(*args, **kwargs)
1054418
def delete(self, *args, **kwargs):
        
        return self.session.delete(*args, **self.get_kwargs(**kwargs))
82049
def delete(options = {})
      options = options.merge(user_name: @user_name)
      resp = @client.delete_login_profile(options)
      resp.data
    end
448480
def delete(options = {})
      options = options.merge(role_name: @name)
      resp = @client.delete_role(options)
      resp.data
    end
600017
def remove(self, param):
        
        if self.has(param):
            del(self.raw_dict[param])
            self.manifest.remove_option(self.feature_name, param)
916527
def delete(options = {})
      options = options.merge(bucket: @bucket_name)
      resp = @client.delete_bucket_tagging(options)
      resp.data
    end
1354118
def abort(self):
        
        self._coll.chunks.delete_many(
            {"files_id": self._file['_id']}, session=self._session)
        self._coll.files.delete_one(
            {"_id": self._file['_id']}, session=self._session)
        object.__setattr__(self, "_closed", True)
1210497
def del_option(self, option):
        
        assert isinstance(option, Option)
        while option in list(self._options):
            self._options.remove(option)
667257
def delete(self, *args, **kwargs):
        
        try:
            os.remove(self.file.file.name)
        # image does not exist
        except (OSError, IOError):
            pass
        super(Image, self).delete(*args, **kwargs)