Delete a video's source file.

 @param id Id of a Video.
 @param factory_id Id of a Factory.
 @param [Hash] opts the optional parameters
 @return [DeletedResponse]
339255
def delete_video_source(id, factory_id, opts = {})
      data, _status_code, _headers = delete_video_source_with_http_info(id, factory_id, opts)
      return data
    end
1315946
def delete(self, ids):
        
        url = build_uri_with_ids('api/v3/pool/%s/', ids)

        return super(ApiPool, self).delete(url)
661721
void deleteResource(String id) throws IOException {
    storeWithRetries(() -> {
      datastore.delete(datastore.newKeyFactory().setKind(KIND_COUNTER_LIMIT).newKey(id));
      return null;
    });
    deleteShardsForCounter(id);
  }
1287501
def delete(self, id):
        
        id = self.key_name(id)
        self.redis.delete(id)
698980
def delete_video(video_id, cascade=False, delete_shares=False,
        _connection=None):
        
        c = _connection
        if not c:
            c = connection.APIConnection()
        c.post('delete_video', video_id=video_id, cascade=cascade,
            delete_shares=delete_shares)
753030
def delete(self, ids):
        
        url = build_uri_with_ids('api/v3/equipment/%s/', ids)
        return super(ApiEquipment, self).delete(url)
465428
def _delete(self, vid=None):
        
        query = text("""
            DELETE FROM dataset_index
            WHERE vid = :vid;
        """)
        self.backend.library.database.connection.execute(query, vid=vid)
1318810
public void deleteService(String id, boolean force) {
        try {
            if (id == null || id.isEmpty()) {
                id = selectRunningService();
            }
            final String idFinal = id;
            int input = 'Y';
            if (!force) {
                OutputStreamFormater.printValue(String.format(
                    "Do you really want to delete the connector: %s (Y/n): ", id));
                input = keyboard.read();
            }
            if ('n' != (char) input && 'N' != (char) input) {
                SecurityContext.executeWithSystemPermissions(new Callable<Object>() {
                    @Override
                    public Object call() throws Exception {
                        serviceManager.delete(idFinal);
                        return null;
                    }
                });
                OutputStreamFormater.printValue(String.format("Service: %s successfully deleted", id));
            }
        } catch (ExecutionException e) {
            e.printStackTrace();
            System.err.println("Could not delete service");
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Unexpected Error");
        }
    }
141467
def delete_subscription(self, subscription_id):
        
        url = self.SUBSCRIPTIONS_ID_URL % subscription_id

        connection = Connection(self.token)
        connection.set_url(self.production, url)

        return connection.delete_request()
1018720
def remove(cls, id):
        

        api = Client.instance().api
        api.index(id).delete()
1193997
def delete(id)
      return true unless id
      with_redis { |redis| redis.del(redis_key_for(id)) }
      true
    end
47437
def delete(request, obj_id=None):
    
    data = request.DELETE or json.loads(request.body)
    guids = data.get('guids').split(',')
    objects = getObjectsFromGuids(guids)
    gallery = Gallery.objects.get(pk=obj_id)

    LOGGER.info('{} removed {} from {}'.format(request.user.email, guids, gallery))

    for o in objects:
        if isinstance(o, Image):
            gallery.images.remove(o)
        elif isinstance(o, Video):
            gallery.videos.remove(o)

    res = Result()

    return JsonResponse(res.asDict())
810531
def delete(self, id):
        
        path = partial(_path, self.adapter)
        path = path(id)
        return self._delete(path)
720783
def delete(self, ids):
        
        url = build_uri_with_ids('api/v4/equipment/%s/', ids)
        return super(ApiV4Equipment, self).delete(url)
806246
public function delete($video_id)
	{
		$accessToken = $this->client->getAccessToken();

		if (is_null($accessToken))
		{
			throw new \Exception('You need an access token to delete.');
		}

		// Attempt to refresh the access token if it's expired and save the new one in the database
		if ($this->client->isAccessTokenExpired())
		{
			$accessToken = json_decode($accessToken);
			$refreshToken = $accessToken->refresh_token;
			$this->client->refreshToken($refreshToken);
			$newAccessToken = $this->client->getAccessToken();
			$this->saveAccessTokenToDB($newAccessToken);
		}

		$result = $this->youtube->videos->delete($video_id);

		if (!$result)
		{
			throw new \Exception("Couldn't delete the video from the youtube account.");
		}

		return $result->getId();

	}
462271
def delete(self, upload_id):
        

        return super(UploadsProxy, self).delete(upload_id, file_upload=True)
672718
def delete_file(self, id):
        
        path = {}
        data = {}
        params = {}

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

        self.logger.debug("DELETE /api/v1/files/{id} with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("DELETE", "/api/v1/files/{id}".format(**path), data=data, params=params, no_data=True)