# coding: utf-8 """ PeerTube The PeerTube API is built on HTTP(S) and is RESTful. You can use your favorite HTTP/REST library for your programming language to use PeerTube. The spec API is fully compatible with [openapi-generator](https://github.com/OpenAPITools/openapi-generator/wiki/API-client-generator-HOWTO) which generates a client SDK in the language of your choice - we generate some client SDKs automatically: - [Python](https://framagit.org/framasoft/peertube/clients/python) - [Go](https://framagit.org/framasoft/peertube/clients/go) - [Kotlin](https://framagit.org/framasoft/peertube/clients/kotlin) See the [REST API quick start](https://docs.joinpeertube.org/api/rest-getting-started) for a few examples of using the PeerTube API. # Authentication When you sign up for an account on a PeerTube instance, you are given the possibility to generate sessions on it, and authenticate there using an access token. Only __one access token can currently be used at a time__. ## Roles Accounts are given permissions based on their role. There are three roles on PeerTube: Administrator, Moderator, and User. See the [roles guide](https://docs.joinpeertube.org/admin/managing-users#roles) for a detail of their permissions. # Errors The API uses standard HTTP status codes to indicate the success or failure of the API call, completed by a [RFC7807-compliant](https://tools.ietf.org/html/rfc7807) response body. ``` HTTP 1.1 404 Not Found Content-Type: application/problem+json; charset=utf-8 { \"detail\": \"Video not found\", \"docs\": \"https://docs.joinpeertube.org/api-rest-reference.html#operation/getVideo\", \"status\": 404, \"title\": \"Not Found\", \"type\": \"about:blank\" } ``` We provide error `type` values for [a growing number of cases](https://github.com/Chocobozzz/PeerTube/blob/develop/packages/models/src/server/core-error-code.enum.ts), but it is still optional. Types are used to disambiguate errors that bear the same status code and are non-obvious: ``` HTTP 1.1 403 Forbidden Content-Type: application/problem+json; charset=utf-8 { \"detail\": \"Cannot get this video regarding follow constraints\", \"docs\": \"https://docs.joinpeertube.org/api-rest-reference.html#operation/getVideo\", \"status\": 403, \"title\": \"Forbidden\", \"type\": \"https://docs.joinpeertube.org/api-rest-reference.html#section/Errors/does_not_respect_follow_constraints\" } ``` Here a 403 error could otherwise mean that the video is private or blocklisted. ### Validation errors Each parameter is evaluated on its own against a set of rules before the route validator proceeds with potential testing involving parameter combinations. Errors coming from validation errors appear earlier and benefit from a more detailed error description: ``` HTTP 1.1 400 Bad Request Content-Type: application/problem+json; charset=utf-8 { \"detail\": \"Incorrect request parameters: id\", \"docs\": \"https://docs.joinpeertube.org/api-rest-reference.html#operation/getVideo\", \"instance\": \"/api/v1/videos/9c9de5e8-0a1e-484a-b099-e80766180\", \"invalid-params\": { \"id\": { \"location\": \"params\", \"msg\": \"Invalid value\", \"param\": \"id\", \"value\": \"9c9de5e8-0a1e-484a-b099-e80766180\" } }, \"status\": 400, \"title\": \"Bad Request\", \"type\": \"about:blank\" } ``` Where `id` is the name of the field concerned by the error, within the route definition. `invalid-params..location` can be either 'params', 'body', 'header', 'query' or 'cookies', and `invalid-params..value` reports the value that didn't pass validation whose `invalid-params..msg` is about. ### Deprecated error fields Some fields could be included with previous versions. They are still included but their use is deprecated: - `error`: superseded by `detail` - `code`: superseded by `type` (which is now an URI) # Rate limits We are rate-limiting all endpoints of PeerTube's API. Custom values can be set by administrators: | Endpoint (prefix: `/api/v1`) | Calls | Time frame | |------------------------------|---------------|--------------| | `/*` | 50 | 10 seconds | | `POST /users/token` | 15 | 5 minutes | | `POST /users/register` | 2* | 5 minutes | | `POST /users/ask-send-verify-email` | 3 | 5 minutes | Depending on the endpoint, *failed requests are not taken into account. A service limit is announced by a `429 Too Many Requests` status code. You can get details about the current state of your rate limit by reading the following headers: | Header | Description | |-------------------------|------------------------------------------------------------| | `X-RateLimit-Limit` | Number of max requests allowed in the current time period | | `X-RateLimit-Remaining` | Number of remaining requests in the current time period | | `X-RateLimit-Reset` | Timestamp of end of current time period as UNIX timestamp | | `Retry-After` | Seconds to delay after the first `429` is received | # CORS This API features [Cross-Origin Resource Sharing (CORS)](https://fetch.spec.whatwg.org/), allowing cross-domain communication from the browser for some routes: | Endpoint | |------------------------- ---| | `/api/*` | | `/download/*` | | `/lazy-static/*` | | `/.well-known/webfinger` | In addition, all routes serving ActivityPub are CORS-enabled for all origins. The version of the OpenAPI document: 5.2.0 Generated by OpenAPI Generator (https://openapi-generator.tech) Do not edit the class manually. """ # noqa: E501 import warnings from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt from typing import Any, Dict, List, Optional, Tuple, Union from typing_extensions import Annotated from datetime import datetime from pydantic import Field, StrictBool, StrictBytes, StrictFloat, StrictInt, StrictStr, field_validator from typing import Any, List, Optional, Union from typing_extensions import Annotated from peertube.models.list_video_storyboards200_response import ListVideoStoryboards200Response from peertube.models.live_video_latency_mode import LiveVideoLatencyMode from peertube.models.live_video_replay_settings import LiveVideoReplaySettings from peertube.models.live_video_response import LiveVideoResponse from peertube.models.live_video_update import LiveVideoUpdate from peertube.models.user_viewing_video import UserViewingVideo from peertube.models.video_details import VideoDetails from peertube.models.video_list_response import VideoListResponse from peertube.models.video_privacy_set import VideoPrivacySet from peertube.models.video_replace_source_request_resumable import VideoReplaceSourceRequestResumable from peertube.models.video_scheduled_update import VideoScheduledUpdate from peertube.models.video_source import VideoSource from peertube.models.video_token_response import VideoTokenResponse from peertube.models.video_upload_request_resumable import VideoUploadRequestResumable from peertube.models.video_upload_response import VideoUploadResponse from peertube.api_client import ApiClient, RequestSerialized from peertube.api_response import ApiResponse from peertube.rest import RESTResponseType class VideoApi: """NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech Do not edit the class manually. """ def __init__(self, api_client=None) -> None: if api_client is None: api_client = ApiClient.get_default() self.api_client = api_client @validate_call def add_live( self, channel_id: Annotated[StrictInt, Field(description="Channel id that will contain this live video")], name: Annotated[str, Field(min_length=3, strict=True, max_length=120, description="Live video/replay name")], save_replay: Optional[StrictBool] = None, replay_settings: Optional[LiveVideoReplaySettings] = None, permanent_live: Annotated[Optional[StrictBool], Field(description="User can stream multiple times in a permanent live")] = None, latency_mode: Optional[LiveVideoLatencyMode] = None, thumbnailfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Live video/replay thumbnail file")] = None, previewfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Live video/replay preview file")] = None, privacy: Optional[VideoPrivacySet] = None, category: Annotated[Optional[StrictInt], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, licence: Annotated[Optional[StrictInt], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language: Annotated[Optional[StrictStr], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages))")] = None, description: Annotated[Optional[StrictStr], Field(description="Live video/replay description")] = None, support: Annotated[Optional[StrictStr], Field(description="A text tell the audience how to support the creator")] = None, nsfw: Annotated[Optional[StrictBool], Field(description="Whether or not this live video/replay contains sensitive content")] = None, tags: Annotated[Optional[Annotated[List[Annotated[str, Field(min_length=2, strict=True, max_length=30)]], Field(min_length=1, max_length=5)]], Field(description="Live video/replay tags (maximum 5 tags each between 2 and 30 characters)")] = None, comments_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable comments for this live video/replay")] = None, download_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable downloading for the replay of this live video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> VideoUploadResponse: """Create a live :param channel_id: Channel id that will contain this live video (required) :type channel_id: int :param name: Live video/replay name (required) :type name: str :param save_replay: :type save_replay: bool :param replay_settings: :type replay_settings: LiveVideoReplaySettings :param permanent_live: User can stream multiple times in a permanent live :type permanent_live: bool :param latency_mode: :type latency_mode: LiveVideoLatencyMode :param thumbnailfile: Live video/replay thumbnail file :type thumbnailfile: bytearray :param previewfile: Live video/replay preview file :type previewfile: bytearray :param privacy: :type privacy: VideoPrivacySet :param category: category id of the video (see [/videos/categories](#operation/getCategories)) :type category: int :param licence: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence: int :param language: language id of the video (see [/videos/languages](#operation/getLanguages)) :type language: str :param description: Live video/replay description :type description: str :param support: A text tell the audience how to support the creator :type support: str :param nsfw: Whether or not this live video/replay contains sensitive content :type nsfw: bool :param tags: Live video/replay tags (maximum 5 tags each between 2 and 30 characters) :type tags: List[str] :param comments_enabled: Enable or disable comments for this live video/replay :type comments_enabled: bool :param download_enabled: Enable or disable downloading for the replay of this live video :type download_enabled: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._add_live_serialize( channel_id=channel_id, name=name, save_replay=save_replay, replay_settings=replay_settings, permanent_live=permanent_live, latency_mode=latency_mode, thumbnailfile=thumbnailfile, previewfile=previewfile, privacy=privacy, category=category, licence=licence, language=language, description=description, support=support, nsfw=nsfw, tags=tags, comments_enabled=comments_enabled, download_enabled=download_enabled, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoUploadResponse", '400': None, '403': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def add_live_with_http_info( self, channel_id: Annotated[StrictInt, Field(description="Channel id that will contain this live video")], name: Annotated[str, Field(min_length=3, strict=True, max_length=120, description="Live video/replay name")], save_replay: Optional[StrictBool] = None, replay_settings: Optional[LiveVideoReplaySettings] = None, permanent_live: Annotated[Optional[StrictBool], Field(description="User can stream multiple times in a permanent live")] = None, latency_mode: Optional[LiveVideoLatencyMode] = None, thumbnailfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Live video/replay thumbnail file")] = None, previewfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Live video/replay preview file")] = None, privacy: Optional[VideoPrivacySet] = None, category: Annotated[Optional[StrictInt], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, licence: Annotated[Optional[StrictInt], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language: Annotated[Optional[StrictStr], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages))")] = None, description: Annotated[Optional[StrictStr], Field(description="Live video/replay description")] = None, support: Annotated[Optional[StrictStr], Field(description="A text tell the audience how to support the creator")] = None, nsfw: Annotated[Optional[StrictBool], Field(description="Whether or not this live video/replay contains sensitive content")] = None, tags: Annotated[Optional[Annotated[List[Annotated[str, Field(min_length=2, strict=True, max_length=30)]], Field(min_length=1, max_length=5)]], Field(description="Live video/replay tags (maximum 5 tags each between 2 and 30 characters)")] = None, comments_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable comments for this live video/replay")] = None, download_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable downloading for the replay of this live video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[VideoUploadResponse]: """Create a live :param channel_id: Channel id that will contain this live video (required) :type channel_id: int :param name: Live video/replay name (required) :type name: str :param save_replay: :type save_replay: bool :param replay_settings: :type replay_settings: LiveVideoReplaySettings :param permanent_live: User can stream multiple times in a permanent live :type permanent_live: bool :param latency_mode: :type latency_mode: LiveVideoLatencyMode :param thumbnailfile: Live video/replay thumbnail file :type thumbnailfile: bytearray :param previewfile: Live video/replay preview file :type previewfile: bytearray :param privacy: :type privacy: VideoPrivacySet :param category: category id of the video (see [/videos/categories](#operation/getCategories)) :type category: int :param licence: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence: int :param language: language id of the video (see [/videos/languages](#operation/getLanguages)) :type language: str :param description: Live video/replay description :type description: str :param support: A text tell the audience how to support the creator :type support: str :param nsfw: Whether or not this live video/replay contains sensitive content :type nsfw: bool :param tags: Live video/replay tags (maximum 5 tags each between 2 and 30 characters) :type tags: List[str] :param comments_enabled: Enable or disable comments for this live video/replay :type comments_enabled: bool :param download_enabled: Enable or disable downloading for the replay of this live video :type download_enabled: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._add_live_serialize( channel_id=channel_id, name=name, save_replay=save_replay, replay_settings=replay_settings, permanent_live=permanent_live, latency_mode=latency_mode, thumbnailfile=thumbnailfile, previewfile=previewfile, privacy=privacy, category=category, licence=licence, language=language, description=description, support=support, nsfw=nsfw, tags=tags, comments_enabled=comments_enabled, download_enabled=download_enabled, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoUploadResponse", '400': None, '403': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def add_live_without_preload_content( self, channel_id: Annotated[StrictInt, Field(description="Channel id that will contain this live video")], name: Annotated[str, Field(min_length=3, strict=True, max_length=120, description="Live video/replay name")], save_replay: Optional[StrictBool] = None, replay_settings: Optional[LiveVideoReplaySettings] = None, permanent_live: Annotated[Optional[StrictBool], Field(description="User can stream multiple times in a permanent live")] = None, latency_mode: Optional[LiveVideoLatencyMode] = None, thumbnailfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Live video/replay thumbnail file")] = None, previewfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Live video/replay preview file")] = None, privacy: Optional[VideoPrivacySet] = None, category: Annotated[Optional[StrictInt], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, licence: Annotated[Optional[StrictInt], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language: Annotated[Optional[StrictStr], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages))")] = None, description: Annotated[Optional[StrictStr], Field(description="Live video/replay description")] = None, support: Annotated[Optional[StrictStr], Field(description="A text tell the audience how to support the creator")] = None, nsfw: Annotated[Optional[StrictBool], Field(description="Whether or not this live video/replay contains sensitive content")] = None, tags: Annotated[Optional[Annotated[List[Annotated[str, Field(min_length=2, strict=True, max_length=30)]], Field(min_length=1, max_length=5)]], Field(description="Live video/replay tags (maximum 5 tags each between 2 and 30 characters)")] = None, comments_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable comments for this live video/replay")] = None, download_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable downloading for the replay of this live video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Create a live :param channel_id: Channel id that will contain this live video (required) :type channel_id: int :param name: Live video/replay name (required) :type name: str :param save_replay: :type save_replay: bool :param replay_settings: :type replay_settings: LiveVideoReplaySettings :param permanent_live: User can stream multiple times in a permanent live :type permanent_live: bool :param latency_mode: :type latency_mode: LiveVideoLatencyMode :param thumbnailfile: Live video/replay thumbnail file :type thumbnailfile: bytearray :param previewfile: Live video/replay preview file :type previewfile: bytearray :param privacy: :type privacy: VideoPrivacySet :param category: category id of the video (see [/videos/categories](#operation/getCategories)) :type category: int :param licence: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence: int :param language: language id of the video (see [/videos/languages](#operation/getLanguages)) :type language: str :param description: Live video/replay description :type description: str :param support: A text tell the audience how to support the creator :type support: str :param nsfw: Whether or not this live video/replay contains sensitive content :type nsfw: bool :param tags: Live video/replay tags (maximum 5 tags each between 2 and 30 characters) :type tags: List[str] :param comments_enabled: Enable or disable comments for this live video/replay :type comments_enabled: bool :param download_enabled: Enable or disable downloading for the replay of this live video :type download_enabled: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._add_live_serialize( channel_id=channel_id, name=name, save_replay=save_replay, replay_settings=replay_settings, permanent_live=permanent_live, latency_mode=latency_mode, thumbnailfile=thumbnailfile, previewfile=previewfile, privacy=privacy, category=category, licence=licence, language=language, description=description, support=support, nsfw=nsfw, tags=tags, comments_enabled=comments_enabled, download_enabled=download_enabled, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoUploadResponse", '400': None, '403': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _add_live_serialize( self, channel_id, name, save_replay, replay_settings, permanent_live, latency_mode, thumbnailfile, previewfile, privacy, category, licence, language, description, support, nsfw, tags, comments_enabled, download_enabled, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { 'tags': 'csv', } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters # process the form parameters if channel_id is not None: _form_params.append(('channelId', channel_id)) if save_replay is not None: _form_params.append(('saveReplay', save_replay)) if replay_settings is not None: _form_params.append(('replaySettings', replay_settings)) if permanent_live is not None: _form_params.append(('permanentLive', permanent_live)) if latency_mode is not None: _form_params.append(('latencyMode', latency_mode)) if thumbnailfile is not None: _files['thumbnailfile'] = thumbnailfile if previewfile is not None: _files['previewfile'] = previewfile if privacy is not None: _form_params.append(('privacy', privacy)) if category is not None: _form_params.append(('category', category)) if licence is not None: _form_params.append(('licence', licence)) if language is not None: _form_params.append(('language', language)) if description is not None: _form_params.append(('description', description)) if support is not None: _form_params.append(('support', support)) if nsfw is not None: _form_params.append(('nsfw', nsfw)) if name is not None: _form_params.append(('name', name)) if tags is not None: _form_params.append(('tags', tags)) if comments_enabled is not None: _form_params.append(('commentsEnabled', comments_enabled)) if download_enabled is not None: _form_params.append(('downloadEnabled', download_enabled)) # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # set the HTTP header `Content-Type` if _content_type: _header_params['Content-Type'] = _content_type else: _default_content_type = ( self.api_client.select_header_content_type( [ 'multipart/form-data' ] ) ) if _default_content_type is not None: _header_params['Content-Type'] = _default_content_type # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='POST', resource_path='/api/v1/videos/live', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def add_view( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], user_viewing_video: UserViewingVideo, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Notify user is watching a video Call this endpoint regularly (every 5-10 seconds for example) to notify the server the user is watching the video. After a while, PeerTube will increase video's viewers counter. If the user is authenticated, PeerTube will also store the current player time. :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param user_viewing_video: (required) :type user_viewing_video: UserViewingVideo :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._add_view_serialize( id=id, user_viewing_video=user_viewing_video, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def add_view_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], user_viewing_video: UserViewingVideo, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Notify user is watching a video Call this endpoint regularly (every 5-10 seconds for example) to notify the server the user is watching the video. After a while, PeerTube will increase video's viewers counter. If the user is authenticated, PeerTube will also store the current player time. :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param user_viewing_video: (required) :type user_viewing_video: UserViewingVideo :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._add_view_serialize( id=id, user_viewing_video=user_viewing_video, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def add_view_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], user_viewing_video: UserViewingVideo, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Notify user is watching a video Call this endpoint regularly (every 5-10 seconds for example) to notify the server the user is watching the video. After a while, PeerTube will increase video's viewers counter. If the user is authenticated, PeerTube will also store the current player time. :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param user_viewing_video: (required) :type user_viewing_video: UserViewingVideo :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._add_view_serialize( id=id, user_viewing_video=user_viewing_video, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _add_view_serialize( self, id, user_viewing_video, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters # process the form parameters # process the body parameter if user_viewing_video is not None: _body_params = user_viewing_video # set the HTTP header `Content-Type` if _content_type: _header_params['Content-Type'] = _content_type else: _default_content_type = ( self.api_client.select_header_content_type( [ 'application/json' ] ) ) if _default_content_type is not None: _header_params['Content-Type'] = _default_content_type # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='POST', resource_path='/api/v1/videos/{id}/views', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def api_v1_videos_id_studio_edit_post( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Create a studio task Create a task to edit a video (cut, add intro/outro etc) :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._api_v1_videos_id_studio_edit_post_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '400': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def api_v1_videos_id_studio_edit_post_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Create a studio task Create a task to edit a video (cut, add intro/outro etc) :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._api_v1_videos_id_studio_edit_post_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '400': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def api_v1_videos_id_studio_edit_post_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Create a studio task Create a task to edit a video (cut, add intro/outro etc) :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._api_v1_videos_id_studio_edit_post_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '400': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _api_v1_videos_id_studio_edit_post_serialize( self, id, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Content-Type` if _content_type: _header_params['Content-Type'] = _content_type else: _default_content_type = ( self.api_client.select_header_content_type( [ 'application/x-www-form-urlencoded' ] ) ) if _default_content_type is not None: _header_params['Content-Type'] = _default_content_type # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='POST', resource_path='/api/v1/videos/{id}/studio/edit', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def api_v1_videos_id_watching_put( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], user_viewing_video: UserViewingVideo, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """(Deprecated) Set watching progress of a video This endpoint has been deprecated. Use `/videos/{id}/views` instead :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param user_viewing_video: (required) :type user_viewing_video: UserViewingVideo :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 warnings.warn("PUT /api/v1/videos/{id}/watching is deprecated.", DeprecationWarning) _param = self._api_v1_videos_id_watching_put_serialize( id=id, user_viewing_video=user_viewing_video, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def api_v1_videos_id_watching_put_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], user_viewing_video: UserViewingVideo, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """(Deprecated) Set watching progress of a video This endpoint has been deprecated. Use `/videos/{id}/views` instead :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param user_viewing_video: (required) :type user_viewing_video: UserViewingVideo :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 warnings.warn("PUT /api/v1/videos/{id}/watching is deprecated.", DeprecationWarning) _param = self._api_v1_videos_id_watching_put_serialize( id=id, user_viewing_video=user_viewing_video, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def api_v1_videos_id_watching_put_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], user_viewing_video: UserViewingVideo, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """(Deprecated) Set watching progress of a video This endpoint has been deprecated. Use `/videos/{id}/views` instead :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param user_viewing_video: (required) :type user_viewing_video: UserViewingVideo :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 warnings.warn("PUT /api/v1/videos/{id}/watching is deprecated.", DeprecationWarning) _param = self._api_v1_videos_id_watching_put_serialize( id=id, user_viewing_video=user_viewing_video, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _api_v1_videos_id_watching_put_serialize( self, id, user_viewing_video, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters # process the form parameters # process the body parameter if user_viewing_video is not None: _body_params = user_viewing_video # set the HTTP header `Content-Type` if _content_type: _header_params['Content-Type'] = _content_type else: _default_content_type = ( self.api_client.select_header_content_type( [ 'application/json' ] ) ) if _default_content_type is not None: _header_params['Content-Type'] = _default_content_type # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='PUT', resource_path='/api/v1/videos/{id}/watching', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def del_video( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Delete a video :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._del_video_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def del_video_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Delete a video :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._del_video_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def del_video_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Delete a video :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._del_video_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _del_video_serialize( self, id, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters # process the form parameters # process the body parameter # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='DELETE', resource_path='/api/v1/videos/{id}', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def get_account_videos( self, name: Annotated[StrictStr, Field(description="The username or handle of the account")], category_one_of: Annotated[Optional[Any], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, is_live: Annotated[Optional[StrictBool], Field(description="whether or not the video is a live")] = None, tags_one_of: Annotated[Optional[Any], Field(description="tag(s) of the video")] = None, tags_all_of: Annotated[Optional[Any], Field(description="tag(s) of the video, where all should be present in the video")] = None, licence_one_of: Annotated[Optional[Any], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language_one_of: Annotated[Optional[Any], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language")] = None, nsfw: Annotated[Optional[StrictStr], Field(description="whether to include nsfw videos, if any")] = None, is_local: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only local or remote videos")] = None, include: Annotated[Optional[StrictInt], Field(description="**PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES ")] = None, privacy_one_of: Annotated[Optional[VideoPrivacySet], Field(description="**PeerTube >= 4.0** Display only videos in this specific privacy/privacies")] = None, has_hls_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only videos that have HLS files")] = None, has_web_video_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 6.0** Display only videos that have Web Video files")] = None, skip_count: Annotated[Optional[StrictStr], Field(description="if you don't need the `total` in the response")] = None, start: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="Offset used to paginate results")] = None, count: Annotated[Optional[Annotated[int, Field(le=100, strict=True, ge=1)]], Field(description="Number of items to return")] = None, sort: Optional[StrictStr] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> VideoListResponse: """List videos of an account :param name: The username or handle of the account (required) :type name: str :param category_one_of: category id of the video (see [/videos/categories](#operation/getCategories)) :type category_one_of: GetAccountVideosCategoryOneOfParameter :param is_live: whether or not the video is a live :type is_live: bool :param tags_one_of: tag(s) of the video :type tags_one_of: GetAccountVideosTagsOneOfParameter :param tags_all_of: tag(s) of the video, where all should be present in the video :type tags_all_of: GetAccountVideosTagsAllOfParameter :param licence_one_of: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence_one_of: GetAccountVideosLicenceOneOfParameter :param language_one_of: language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language :type language_one_of: GetAccountVideosLanguageOneOfParameter :param nsfw: whether to include nsfw videos, if any :type nsfw: str :param is_local: **PeerTube >= 4.0** Display only local or remote videos :type is_local: bool :param include: **PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES :type include: int :param privacy_one_of: **PeerTube >= 4.0** Display only videos in this specific privacy/privacies :type privacy_one_of: VideoPrivacySet :param has_hls_files: **PeerTube >= 4.0** Display only videos that have HLS files :type has_hls_files: bool :param has_web_video_files: **PeerTube >= 6.0** Display only videos that have Web Video files :type has_web_video_files: bool :param skip_count: if you don't need the `total` in the response :type skip_count: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param sort: :type sort: str :param exclude_already_watched: Whether or not to exclude videos that are in the user's video history :type exclude_already_watched: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_account_videos_serialize( name=name, category_one_of=category_one_of, is_live=is_live, tags_one_of=tags_one_of, tags_all_of=tags_all_of, licence_one_of=licence_one_of, language_one_of=language_one_of, nsfw=nsfw, is_local=is_local, include=include, privacy_one_of=privacy_one_of, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, sort=sort, exclude_already_watched=exclude_already_watched, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def get_account_videos_with_http_info( self, name: Annotated[StrictStr, Field(description="The username or handle of the account")], category_one_of: Annotated[Optional[Any], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, is_live: Annotated[Optional[StrictBool], Field(description="whether or not the video is a live")] = None, tags_one_of: Annotated[Optional[Any], Field(description="tag(s) of the video")] = None, tags_all_of: Annotated[Optional[Any], Field(description="tag(s) of the video, where all should be present in the video")] = None, licence_one_of: Annotated[Optional[Any], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language_one_of: Annotated[Optional[Any], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language")] = None, nsfw: Annotated[Optional[StrictStr], Field(description="whether to include nsfw videos, if any")] = None, is_local: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only local or remote videos")] = None, include: Annotated[Optional[StrictInt], Field(description="**PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES ")] = None, privacy_one_of: Annotated[Optional[VideoPrivacySet], Field(description="**PeerTube >= 4.0** Display only videos in this specific privacy/privacies")] = None, has_hls_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only videos that have HLS files")] = None, has_web_video_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 6.0** Display only videos that have Web Video files")] = None, skip_count: Annotated[Optional[StrictStr], Field(description="if you don't need the `total` in the response")] = None, start: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="Offset used to paginate results")] = None, count: Annotated[Optional[Annotated[int, Field(le=100, strict=True, ge=1)]], Field(description="Number of items to return")] = None, sort: Optional[StrictStr] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[VideoListResponse]: """List videos of an account :param name: The username or handle of the account (required) :type name: str :param category_one_of: category id of the video (see [/videos/categories](#operation/getCategories)) :type category_one_of: GetAccountVideosCategoryOneOfParameter :param is_live: whether or not the video is a live :type is_live: bool :param tags_one_of: tag(s) of the video :type tags_one_of: GetAccountVideosTagsOneOfParameter :param tags_all_of: tag(s) of the video, where all should be present in the video :type tags_all_of: GetAccountVideosTagsAllOfParameter :param licence_one_of: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence_one_of: GetAccountVideosLicenceOneOfParameter :param language_one_of: language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language :type language_one_of: GetAccountVideosLanguageOneOfParameter :param nsfw: whether to include nsfw videos, if any :type nsfw: str :param is_local: **PeerTube >= 4.0** Display only local or remote videos :type is_local: bool :param include: **PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES :type include: int :param privacy_one_of: **PeerTube >= 4.0** Display only videos in this specific privacy/privacies :type privacy_one_of: VideoPrivacySet :param has_hls_files: **PeerTube >= 4.0** Display only videos that have HLS files :type has_hls_files: bool :param has_web_video_files: **PeerTube >= 6.0** Display only videos that have Web Video files :type has_web_video_files: bool :param skip_count: if you don't need the `total` in the response :type skip_count: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param sort: :type sort: str :param exclude_already_watched: Whether or not to exclude videos that are in the user's video history :type exclude_already_watched: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_account_videos_serialize( name=name, category_one_of=category_one_of, is_live=is_live, tags_one_of=tags_one_of, tags_all_of=tags_all_of, licence_one_of=licence_one_of, language_one_of=language_one_of, nsfw=nsfw, is_local=is_local, include=include, privacy_one_of=privacy_one_of, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, sort=sort, exclude_already_watched=exclude_already_watched, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def get_account_videos_without_preload_content( self, name: Annotated[StrictStr, Field(description="The username or handle of the account")], category_one_of: Annotated[Optional[Any], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, is_live: Annotated[Optional[StrictBool], Field(description="whether or not the video is a live")] = None, tags_one_of: Annotated[Optional[Any], Field(description="tag(s) of the video")] = None, tags_all_of: Annotated[Optional[Any], Field(description="tag(s) of the video, where all should be present in the video")] = None, licence_one_of: Annotated[Optional[Any], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language_one_of: Annotated[Optional[Any], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language")] = None, nsfw: Annotated[Optional[StrictStr], Field(description="whether to include nsfw videos, if any")] = None, is_local: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only local or remote videos")] = None, include: Annotated[Optional[StrictInt], Field(description="**PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES ")] = None, privacy_one_of: Annotated[Optional[VideoPrivacySet], Field(description="**PeerTube >= 4.0** Display only videos in this specific privacy/privacies")] = None, has_hls_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only videos that have HLS files")] = None, has_web_video_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 6.0** Display only videos that have Web Video files")] = None, skip_count: Annotated[Optional[StrictStr], Field(description="if you don't need the `total` in the response")] = None, start: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="Offset used to paginate results")] = None, count: Annotated[Optional[Annotated[int, Field(le=100, strict=True, ge=1)]], Field(description="Number of items to return")] = None, sort: Optional[StrictStr] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List videos of an account :param name: The username or handle of the account (required) :type name: str :param category_one_of: category id of the video (see [/videos/categories](#operation/getCategories)) :type category_one_of: GetAccountVideosCategoryOneOfParameter :param is_live: whether or not the video is a live :type is_live: bool :param tags_one_of: tag(s) of the video :type tags_one_of: GetAccountVideosTagsOneOfParameter :param tags_all_of: tag(s) of the video, where all should be present in the video :type tags_all_of: GetAccountVideosTagsAllOfParameter :param licence_one_of: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence_one_of: GetAccountVideosLicenceOneOfParameter :param language_one_of: language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language :type language_one_of: GetAccountVideosLanguageOneOfParameter :param nsfw: whether to include nsfw videos, if any :type nsfw: str :param is_local: **PeerTube >= 4.0** Display only local or remote videos :type is_local: bool :param include: **PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES :type include: int :param privacy_one_of: **PeerTube >= 4.0** Display only videos in this specific privacy/privacies :type privacy_one_of: VideoPrivacySet :param has_hls_files: **PeerTube >= 4.0** Display only videos that have HLS files :type has_hls_files: bool :param has_web_video_files: **PeerTube >= 6.0** Display only videos that have Web Video files :type has_web_video_files: bool :param skip_count: if you don't need the `total` in the response :type skip_count: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param sort: :type sort: str :param exclude_already_watched: Whether or not to exclude videos that are in the user's video history :type exclude_already_watched: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_account_videos_serialize( name=name, category_one_of=category_one_of, is_live=is_live, tags_one_of=tags_one_of, tags_all_of=tags_all_of, licence_one_of=licence_one_of, language_one_of=language_one_of, nsfw=nsfw, is_local=is_local, include=include, privacy_one_of=privacy_one_of, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, sort=sort, exclude_already_watched=exclude_already_watched, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _get_account_videos_serialize( self, name, category_one_of, is_live, tags_one_of, tags_all_of, licence_one_of, language_one_of, nsfw, is_local, include, privacy_one_of, has_hls_files, has_web_video_files, skip_count, start, count, sort, exclude_already_watched, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if name is not None: _path_params['name'] = name # process the query parameters if category_one_of is not None: _query_params.append(('categoryOneOf', category_one_of)) if is_live is not None: _query_params.append(('isLive', is_live)) if tags_one_of is not None: _query_params.append(('tagsOneOf', tags_one_of)) if tags_all_of is not None: _query_params.append(('tagsAllOf', tags_all_of)) if licence_one_of is not None: _query_params.append(('licenceOneOf', licence_one_of)) if language_one_of is not None: _query_params.append(('languageOneOf', language_one_of)) if nsfw is not None: _query_params.append(('nsfw', nsfw)) if is_local is not None: _query_params.append(('isLocal', is_local)) if include is not None: _query_params.append(('include', include)) if privacy_one_of is not None: _query_params.append(('privacyOneOf', privacy_one_of.value)) if has_hls_files is not None: _query_params.append(('hasHLSFiles', has_hls_files)) if has_web_video_files is not None: _query_params.append(('hasWebVideoFiles', has_web_video_files)) if skip_count is not None: _query_params.append(('skipCount', skip_count)) if start is not None: _query_params.append(('start', start)) if count is not None: _query_params.append(('count', count)) if sort is not None: _query_params.append(('sort', sort)) if exclude_already_watched is not None: _query_params.append(('excludeAlreadyWatched', exclude_already_watched)) # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/accounts/{name}/videos', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def get_categories( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> List[str]: """List available video categories :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_categories_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def get_categories_with_http_info( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[List[str]]: """List available video categories :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_categories_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def get_categories_without_preload_content( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List available video categories :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_categories_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _get_categories_serialize( self, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/videos/categories', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def get_languages( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> List[str]: """List available video languages :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_languages_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def get_languages_with_http_info( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[List[str]]: """List available video languages :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_languages_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def get_languages_without_preload_content( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List available video languages :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_languages_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _get_languages_serialize( self, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/videos/languages', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def get_licences( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> List[str]: """List available video licences :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_licences_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def get_licences_with_http_info( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[List[str]]: """List available video licences :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_licences_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def get_licences_without_preload_content( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List available video licences :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_licences_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _get_licences_serialize( self, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/videos/licences', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def get_live_id( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> LiveVideoResponse: """Get information about a live :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_live_id_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "LiveVideoResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def get_live_id_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[LiveVideoResponse]: """Get information about a live :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_live_id_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "LiveVideoResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def get_live_id_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Get information about a live :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_live_id_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "LiveVideoResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _get_live_id_serialize( self, id, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/videos/live/{id}', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def get_video( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], x_peertube_video_password: Annotated[Optional[StrictStr], Field(description="Required on password protected video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> VideoDetails: """Get a video :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param x_peertube_video_password: Required on password protected video :type x_peertube_video_password: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_serialize( id=id, x_peertube_video_password=x_peertube_video_password, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoDetails", '403': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def get_video_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], x_peertube_video_password: Annotated[Optional[StrictStr], Field(description="Required on password protected video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[VideoDetails]: """Get a video :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param x_peertube_video_password: Required on password protected video :type x_peertube_video_password: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_serialize( id=id, x_peertube_video_password=x_peertube_video_password, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoDetails", '403': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def get_video_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], x_peertube_video_password: Annotated[Optional[StrictStr], Field(description="Required on password protected video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Get a video :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param x_peertube_video_password: Required on password protected video :type x_peertube_video_password: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_serialize( id=id, x_peertube_video_password=x_peertube_video_password, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoDetails", '403': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _get_video_serialize( self, id, x_peertube_video_password, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters if x_peertube_video_password is not None: _header_params['x-peertube-video-password'] = x_peertube_video_password # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/videos/{id}', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def get_video_channel_videos( self, channel_handle: Annotated[StrictStr, Field(description="The video channel handle")], category_one_of: Annotated[Optional[Any], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, is_live: Annotated[Optional[StrictBool], Field(description="whether or not the video is a live")] = None, tags_one_of: Annotated[Optional[Any], Field(description="tag(s) of the video")] = None, tags_all_of: Annotated[Optional[Any], Field(description="tag(s) of the video, where all should be present in the video")] = None, licence_one_of: Annotated[Optional[Any], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language_one_of: Annotated[Optional[Any], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language")] = None, nsfw: Annotated[Optional[StrictStr], Field(description="whether to include nsfw videos, if any")] = None, is_local: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only local or remote videos")] = None, include: Annotated[Optional[StrictInt], Field(description="**PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES ")] = None, privacy_one_of: Annotated[Optional[VideoPrivacySet], Field(description="**PeerTube >= 4.0** Display only videos in this specific privacy/privacies")] = None, has_hls_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only videos that have HLS files")] = None, has_web_video_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 6.0** Display only videos that have Web Video files")] = None, skip_count: Annotated[Optional[StrictStr], Field(description="if you don't need the `total` in the response")] = None, start: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="Offset used to paginate results")] = None, count: Annotated[Optional[Annotated[int, Field(le=100, strict=True, ge=1)]], Field(description="Number of items to return")] = None, sort: Optional[StrictStr] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> VideoListResponse: """List videos of a video channel :param channel_handle: The video channel handle (required) :type channel_handle: str :param category_one_of: category id of the video (see [/videos/categories](#operation/getCategories)) :type category_one_of: GetAccountVideosCategoryOneOfParameter :param is_live: whether or not the video is a live :type is_live: bool :param tags_one_of: tag(s) of the video :type tags_one_of: GetAccountVideosTagsOneOfParameter :param tags_all_of: tag(s) of the video, where all should be present in the video :type tags_all_of: GetAccountVideosTagsAllOfParameter :param licence_one_of: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence_one_of: GetAccountVideosLicenceOneOfParameter :param language_one_of: language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language :type language_one_of: GetAccountVideosLanguageOneOfParameter :param nsfw: whether to include nsfw videos, if any :type nsfw: str :param is_local: **PeerTube >= 4.0** Display only local or remote videos :type is_local: bool :param include: **PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES :type include: int :param privacy_one_of: **PeerTube >= 4.0** Display only videos in this specific privacy/privacies :type privacy_one_of: VideoPrivacySet :param has_hls_files: **PeerTube >= 4.0** Display only videos that have HLS files :type has_hls_files: bool :param has_web_video_files: **PeerTube >= 6.0** Display only videos that have Web Video files :type has_web_video_files: bool :param skip_count: if you don't need the `total` in the response :type skip_count: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param sort: :type sort: str :param exclude_already_watched: Whether or not to exclude videos that are in the user's video history :type exclude_already_watched: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_channel_videos_serialize( channel_handle=channel_handle, category_one_of=category_one_of, is_live=is_live, tags_one_of=tags_one_of, tags_all_of=tags_all_of, licence_one_of=licence_one_of, language_one_of=language_one_of, nsfw=nsfw, is_local=is_local, include=include, privacy_one_of=privacy_one_of, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, sort=sort, exclude_already_watched=exclude_already_watched, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def get_video_channel_videos_with_http_info( self, channel_handle: Annotated[StrictStr, Field(description="The video channel handle")], category_one_of: Annotated[Optional[Any], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, is_live: Annotated[Optional[StrictBool], Field(description="whether or not the video is a live")] = None, tags_one_of: Annotated[Optional[Any], Field(description="tag(s) of the video")] = None, tags_all_of: Annotated[Optional[Any], Field(description="tag(s) of the video, where all should be present in the video")] = None, licence_one_of: Annotated[Optional[Any], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language_one_of: Annotated[Optional[Any], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language")] = None, nsfw: Annotated[Optional[StrictStr], Field(description="whether to include nsfw videos, if any")] = None, is_local: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only local or remote videos")] = None, include: Annotated[Optional[StrictInt], Field(description="**PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES ")] = None, privacy_one_of: Annotated[Optional[VideoPrivacySet], Field(description="**PeerTube >= 4.0** Display only videos in this specific privacy/privacies")] = None, has_hls_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only videos that have HLS files")] = None, has_web_video_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 6.0** Display only videos that have Web Video files")] = None, skip_count: Annotated[Optional[StrictStr], Field(description="if you don't need the `total` in the response")] = None, start: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="Offset used to paginate results")] = None, count: Annotated[Optional[Annotated[int, Field(le=100, strict=True, ge=1)]], Field(description="Number of items to return")] = None, sort: Optional[StrictStr] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[VideoListResponse]: """List videos of a video channel :param channel_handle: The video channel handle (required) :type channel_handle: str :param category_one_of: category id of the video (see [/videos/categories](#operation/getCategories)) :type category_one_of: GetAccountVideosCategoryOneOfParameter :param is_live: whether or not the video is a live :type is_live: bool :param tags_one_of: tag(s) of the video :type tags_one_of: GetAccountVideosTagsOneOfParameter :param tags_all_of: tag(s) of the video, where all should be present in the video :type tags_all_of: GetAccountVideosTagsAllOfParameter :param licence_one_of: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence_one_of: GetAccountVideosLicenceOneOfParameter :param language_one_of: language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language :type language_one_of: GetAccountVideosLanguageOneOfParameter :param nsfw: whether to include nsfw videos, if any :type nsfw: str :param is_local: **PeerTube >= 4.0** Display only local or remote videos :type is_local: bool :param include: **PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES :type include: int :param privacy_one_of: **PeerTube >= 4.0** Display only videos in this specific privacy/privacies :type privacy_one_of: VideoPrivacySet :param has_hls_files: **PeerTube >= 4.0** Display only videos that have HLS files :type has_hls_files: bool :param has_web_video_files: **PeerTube >= 6.0** Display only videos that have Web Video files :type has_web_video_files: bool :param skip_count: if you don't need the `total` in the response :type skip_count: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param sort: :type sort: str :param exclude_already_watched: Whether or not to exclude videos that are in the user's video history :type exclude_already_watched: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_channel_videos_serialize( channel_handle=channel_handle, category_one_of=category_one_of, is_live=is_live, tags_one_of=tags_one_of, tags_all_of=tags_all_of, licence_one_of=licence_one_of, language_one_of=language_one_of, nsfw=nsfw, is_local=is_local, include=include, privacy_one_of=privacy_one_of, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, sort=sort, exclude_already_watched=exclude_already_watched, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def get_video_channel_videos_without_preload_content( self, channel_handle: Annotated[StrictStr, Field(description="The video channel handle")], category_one_of: Annotated[Optional[Any], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, is_live: Annotated[Optional[StrictBool], Field(description="whether or not the video is a live")] = None, tags_one_of: Annotated[Optional[Any], Field(description="tag(s) of the video")] = None, tags_all_of: Annotated[Optional[Any], Field(description="tag(s) of the video, where all should be present in the video")] = None, licence_one_of: Annotated[Optional[Any], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language_one_of: Annotated[Optional[Any], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language")] = None, nsfw: Annotated[Optional[StrictStr], Field(description="whether to include nsfw videos, if any")] = None, is_local: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only local or remote videos")] = None, include: Annotated[Optional[StrictInt], Field(description="**PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES ")] = None, privacy_one_of: Annotated[Optional[VideoPrivacySet], Field(description="**PeerTube >= 4.0** Display only videos in this specific privacy/privacies")] = None, has_hls_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only videos that have HLS files")] = None, has_web_video_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 6.0** Display only videos that have Web Video files")] = None, skip_count: Annotated[Optional[StrictStr], Field(description="if you don't need the `total` in the response")] = None, start: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="Offset used to paginate results")] = None, count: Annotated[Optional[Annotated[int, Field(le=100, strict=True, ge=1)]], Field(description="Number of items to return")] = None, sort: Optional[StrictStr] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List videos of a video channel :param channel_handle: The video channel handle (required) :type channel_handle: str :param category_one_of: category id of the video (see [/videos/categories](#operation/getCategories)) :type category_one_of: GetAccountVideosCategoryOneOfParameter :param is_live: whether or not the video is a live :type is_live: bool :param tags_one_of: tag(s) of the video :type tags_one_of: GetAccountVideosTagsOneOfParameter :param tags_all_of: tag(s) of the video, where all should be present in the video :type tags_all_of: GetAccountVideosTagsAllOfParameter :param licence_one_of: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence_one_of: GetAccountVideosLicenceOneOfParameter :param language_one_of: language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language :type language_one_of: GetAccountVideosLanguageOneOfParameter :param nsfw: whether to include nsfw videos, if any :type nsfw: str :param is_local: **PeerTube >= 4.0** Display only local or remote videos :type is_local: bool :param include: **PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES :type include: int :param privacy_one_of: **PeerTube >= 4.0** Display only videos in this specific privacy/privacies :type privacy_one_of: VideoPrivacySet :param has_hls_files: **PeerTube >= 4.0** Display only videos that have HLS files :type has_hls_files: bool :param has_web_video_files: **PeerTube >= 6.0** Display only videos that have Web Video files :type has_web_video_files: bool :param skip_count: if you don't need the `total` in the response :type skip_count: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param sort: :type sort: str :param exclude_already_watched: Whether or not to exclude videos that are in the user's video history :type exclude_already_watched: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_channel_videos_serialize( channel_handle=channel_handle, category_one_of=category_one_of, is_live=is_live, tags_one_of=tags_one_of, tags_all_of=tags_all_of, licence_one_of=licence_one_of, language_one_of=language_one_of, nsfw=nsfw, is_local=is_local, include=include, privacy_one_of=privacy_one_of, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, sort=sort, exclude_already_watched=exclude_already_watched, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _get_video_channel_videos_serialize( self, channel_handle, category_one_of, is_live, tags_one_of, tags_all_of, licence_one_of, language_one_of, nsfw, is_local, include, privacy_one_of, has_hls_files, has_web_video_files, skip_count, start, count, sort, exclude_already_watched, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if channel_handle is not None: _path_params['channelHandle'] = channel_handle # process the query parameters if category_one_of is not None: _query_params.append(('categoryOneOf', category_one_of)) if is_live is not None: _query_params.append(('isLive', is_live)) if tags_one_of is not None: _query_params.append(('tagsOneOf', tags_one_of)) if tags_all_of is not None: _query_params.append(('tagsAllOf', tags_all_of)) if licence_one_of is not None: _query_params.append(('licenceOneOf', licence_one_of)) if language_one_of is not None: _query_params.append(('languageOneOf', language_one_of)) if nsfw is not None: _query_params.append(('nsfw', nsfw)) if is_local is not None: _query_params.append(('isLocal', is_local)) if include is not None: _query_params.append(('include', include)) if privacy_one_of is not None: _query_params.append(('privacyOneOf', privacy_one_of.value)) if has_hls_files is not None: _query_params.append(('hasHLSFiles', has_hls_files)) if has_web_video_files is not None: _query_params.append(('hasWebVideoFiles', has_web_video_files)) if skip_count is not None: _query_params.append(('skipCount', skip_count)) if start is not None: _query_params.append(('start', start)) if count is not None: _query_params.append(('count', count)) if sort is not None: _query_params.append(('sort', sort)) if exclude_already_watched is not None: _query_params.append(('excludeAlreadyWatched', exclude_already_watched)) # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/video-channels/{channelHandle}/videos', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def get_video_desc( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], x_peertube_video_password: Annotated[Optional[StrictStr], Field(description="Required on password protected video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> str: """Get complete video description :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param x_peertube_video_password: Required on password protected video :type x_peertube_video_password: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_desc_serialize( id=id, x_peertube_video_password=x_peertube_video_password, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "str", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def get_video_desc_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], x_peertube_video_password: Annotated[Optional[StrictStr], Field(description="Required on password protected video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[str]: """Get complete video description :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param x_peertube_video_password: Required on password protected video :type x_peertube_video_password: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_desc_serialize( id=id, x_peertube_video_password=x_peertube_video_password, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "str", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def get_video_desc_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], x_peertube_video_password: Annotated[Optional[StrictStr], Field(description="Required on password protected video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Get complete video description :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param x_peertube_video_password: Required on password protected video :type x_peertube_video_password: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_desc_serialize( id=id, x_peertube_video_password=x_peertube_video_password, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "str", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _get_video_desc_serialize( self, id, x_peertube_video_password, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters if x_peertube_video_password is not None: _header_params['x-peertube-video-password'] = x_peertube_video_password # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/videos/{id}/description', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def get_video_privacy_policies( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> List[str]: """List available video privacy policies :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_privacy_policies_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def get_video_privacy_policies_with_http_info( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[List[str]]: """List available video privacy policies :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_privacy_policies_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def get_video_privacy_policies_without_preload_content( self, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List available video privacy policies :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_privacy_policies_serialize( _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "List[str]", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _get_video_privacy_policies_serialize( self, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/videos/privacies', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def get_video_source( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> VideoSource: """Get video source file metadata :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_source_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoSource", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def get_video_source_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[VideoSource]: """Get video source file metadata :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_source_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoSource", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def get_video_source_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Get video source file metadata :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_video_source_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoSource", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _get_video_source_serialize( self, id, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/videos/{id}/source', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def get_videos( self, category_one_of: Annotated[Optional[Any], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, is_live: Annotated[Optional[StrictBool], Field(description="whether or not the video is a live")] = None, tags_one_of: Annotated[Optional[Any], Field(description="tag(s) of the video")] = None, tags_all_of: Annotated[Optional[Any], Field(description="tag(s) of the video, where all should be present in the video")] = None, licence_one_of: Annotated[Optional[Any], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language_one_of: Annotated[Optional[Any], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language")] = None, nsfw: Annotated[Optional[StrictStr], Field(description="whether to include nsfw videos, if any")] = None, is_local: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only local or remote videos")] = None, include: Annotated[Optional[StrictInt], Field(description="**PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES ")] = None, privacy_one_of: Annotated[Optional[VideoPrivacySet], Field(description="**PeerTube >= 4.0** Display only videos in this specific privacy/privacies")] = None, has_hls_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only videos that have HLS files")] = None, has_web_video_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 6.0** Display only videos that have Web Video files")] = None, skip_count: Annotated[Optional[StrictStr], Field(description="if you don't need the `total` in the response")] = None, start: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="Offset used to paginate results")] = None, count: Annotated[Optional[Annotated[int, Field(le=100, strict=True, ge=1)]], Field(description="Number of items to return")] = None, sort: Optional[StrictStr] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> VideoListResponse: """List videos :param category_one_of: category id of the video (see [/videos/categories](#operation/getCategories)) :type category_one_of: GetAccountVideosCategoryOneOfParameter :param is_live: whether or not the video is a live :type is_live: bool :param tags_one_of: tag(s) of the video :type tags_one_of: GetAccountVideosTagsOneOfParameter :param tags_all_of: tag(s) of the video, where all should be present in the video :type tags_all_of: GetAccountVideosTagsAllOfParameter :param licence_one_of: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence_one_of: GetAccountVideosLicenceOneOfParameter :param language_one_of: language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language :type language_one_of: GetAccountVideosLanguageOneOfParameter :param nsfw: whether to include nsfw videos, if any :type nsfw: str :param is_local: **PeerTube >= 4.0** Display only local or remote videos :type is_local: bool :param include: **PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES :type include: int :param privacy_one_of: **PeerTube >= 4.0** Display only videos in this specific privacy/privacies :type privacy_one_of: VideoPrivacySet :param has_hls_files: **PeerTube >= 4.0** Display only videos that have HLS files :type has_hls_files: bool :param has_web_video_files: **PeerTube >= 6.0** Display only videos that have Web Video files :type has_web_video_files: bool :param skip_count: if you don't need the `total` in the response :type skip_count: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param sort: :type sort: str :param exclude_already_watched: Whether or not to exclude videos that are in the user's video history :type exclude_already_watched: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_videos_serialize( category_one_of=category_one_of, is_live=is_live, tags_one_of=tags_one_of, tags_all_of=tags_all_of, licence_one_of=licence_one_of, language_one_of=language_one_of, nsfw=nsfw, is_local=is_local, include=include, privacy_one_of=privacy_one_of, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, sort=sort, exclude_already_watched=exclude_already_watched, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def get_videos_with_http_info( self, category_one_of: Annotated[Optional[Any], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, is_live: Annotated[Optional[StrictBool], Field(description="whether or not the video is a live")] = None, tags_one_of: Annotated[Optional[Any], Field(description="tag(s) of the video")] = None, tags_all_of: Annotated[Optional[Any], Field(description="tag(s) of the video, where all should be present in the video")] = None, licence_one_of: Annotated[Optional[Any], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language_one_of: Annotated[Optional[Any], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language")] = None, nsfw: Annotated[Optional[StrictStr], Field(description="whether to include nsfw videos, if any")] = None, is_local: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only local or remote videos")] = None, include: Annotated[Optional[StrictInt], Field(description="**PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES ")] = None, privacy_one_of: Annotated[Optional[VideoPrivacySet], Field(description="**PeerTube >= 4.0** Display only videos in this specific privacy/privacies")] = None, has_hls_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only videos that have HLS files")] = None, has_web_video_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 6.0** Display only videos that have Web Video files")] = None, skip_count: Annotated[Optional[StrictStr], Field(description="if you don't need the `total` in the response")] = None, start: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="Offset used to paginate results")] = None, count: Annotated[Optional[Annotated[int, Field(le=100, strict=True, ge=1)]], Field(description="Number of items to return")] = None, sort: Optional[StrictStr] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[VideoListResponse]: """List videos :param category_one_of: category id of the video (see [/videos/categories](#operation/getCategories)) :type category_one_of: GetAccountVideosCategoryOneOfParameter :param is_live: whether or not the video is a live :type is_live: bool :param tags_one_of: tag(s) of the video :type tags_one_of: GetAccountVideosTagsOneOfParameter :param tags_all_of: tag(s) of the video, where all should be present in the video :type tags_all_of: GetAccountVideosTagsAllOfParameter :param licence_one_of: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence_one_of: GetAccountVideosLicenceOneOfParameter :param language_one_of: language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language :type language_one_of: GetAccountVideosLanguageOneOfParameter :param nsfw: whether to include nsfw videos, if any :type nsfw: str :param is_local: **PeerTube >= 4.0** Display only local or remote videos :type is_local: bool :param include: **PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES :type include: int :param privacy_one_of: **PeerTube >= 4.0** Display only videos in this specific privacy/privacies :type privacy_one_of: VideoPrivacySet :param has_hls_files: **PeerTube >= 4.0** Display only videos that have HLS files :type has_hls_files: bool :param has_web_video_files: **PeerTube >= 6.0** Display only videos that have Web Video files :type has_web_video_files: bool :param skip_count: if you don't need the `total` in the response :type skip_count: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param sort: :type sort: str :param exclude_already_watched: Whether or not to exclude videos that are in the user's video history :type exclude_already_watched: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_videos_serialize( category_one_of=category_one_of, is_live=is_live, tags_one_of=tags_one_of, tags_all_of=tags_all_of, licence_one_of=licence_one_of, language_one_of=language_one_of, nsfw=nsfw, is_local=is_local, include=include, privacy_one_of=privacy_one_of, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, sort=sort, exclude_already_watched=exclude_already_watched, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def get_videos_without_preload_content( self, category_one_of: Annotated[Optional[Any], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, is_live: Annotated[Optional[StrictBool], Field(description="whether or not the video is a live")] = None, tags_one_of: Annotated[Optional[Any], Field(description="tag(s) of the video")] = None, tags_all_of: Annotated[Optional[Any], Field(description="tag(s) of the video, where all should be present in the video")] = None, licence_one_of: Annotated[Optional[Any], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language_one_of: Annotated[Optional[Any], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language")] = None, nsfw: Annotated[Optional[StrictStr], Field(description="whether to include nsfw videos, if any")] = None, is_local: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only local or remote videos")] = None, include: Annotated[Optional[StrictInt], Field(description="**PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES ")] = None, privacy_one_of: Annotated[Optional[VideoPrivacySet], Field(description="**PeerTube >= 4.0** Display only videos in this specific privacy/privacies")] = None, has_hls_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 4.0** Display only videos that have HLS files")] = None, has_web_video_files: Annotated[Optional[StrictBool], Field(description="**PeerTube >= 6.0** Display only videos that have Web Video files")] = None, skip_count: Annotated[Optional[StrictStr], Field(description="if you don't need the `total` in the response")] = None, start: Annotated[Optional[Annotated[int, Field(strict=True, ge=0)]], Field(description="Offset used to paginate results")] = None, count: Annotated[Optional[Annotated[int, Field(le=100, strict=True, ge=1)]], Field(description="Number of items to return")] = None, sort: Optional[StrictStr] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List videos :param category_one_of: category id of the video (see [/videos/categories](#operation/getCategories)) :type category_one_of: GetAccountVideosCategoryOneOfParameter :param is_live: whether or not the video is a live :type is_live: bool :param tags_one_of: tag(s) of the video :type tags_one_of: GetAccountVideosTagsOneOfParameter :param tags_all_of: tag(s) of the video, where all should be present in the video :type tags_all_of: GetAccountVideosTagsAllOfParameter :param licence_one_of: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence_one_of: GetAccountVideosLicenceOneOfParameter :param language_one_of: language id of the video (see [/videos/languages](#operation/getLanguages)). Use `_unknown` to filter on videos that don't have a video language :type language_one_of: GetAccountVideosLanguageOneOfParameter :param nsfw: whether to include nsfw videos, if any :type nsfw: str :param is_local: **PeerTube >= 4.0** Display only local or remote videos :type is_local: bool :param include: **PeerTube >= 4.0** Include additional videos in results (can be combined using bitwise or operator) - `0` NONE - `1` NOT_PUBLISHED_STATE - `2` BLACKLISTED - `4` BLOCKED_OWNER - `8` FILES :type include: int :param privacy_one_of: **PeerTube >= 4.0** Display only videos in this specific privacy/privacies :type privacy_one_of: VideoPrivacySet :param has_hls_files: **PeerTube >= 4.0** Display only videos that have HLS files :type has_hls_files: bool :param has_web_video_files: **PeerTube >= 6.0** Display only videos that have Web Video files :type has_web_video_files: bool :param skip_count: if you don't need the `total` in the response :type skip_count: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param sort: :type sort: str :param exclude_already_watched: Whether or not to exclude videos that are in the user's video history :type exclude_already_watched: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._get_videos_serialize( category_one_of=category_one_of, is_live=is_live, tags_one_of=tags_one_of, tags_all_of=tags_all_of, licence_one_of=licence_one_of, language_one_of=language_one_of, nsfw=nsfw, is_local=is_local, include=include, privacy_one_of=privacy_one_of, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, sort=sort, exclude_already_watched=exclude_already_watched, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _get_videos_serialize( self, category_one_of, is_live, tags_one_of, tags_all_of, licence_one_of, language_one_of, nsfw, is_local, include, privacy_one_of, has_hls_files, has_web_video_files, skip_count, start, count, sort, exclude_already_watched, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters if category_one_of is not None: _query_params.append(('categoryOneOf', category_one_of)) if is_live is not None: _query_params.append(('isLive', is_live)) if tags_one_of is not None: _query_params.append(('tagsOneOf', tags_one_of)) if tags_all_of is not None: _query_params.append(('tagsAllOf', tags_all_of)) if licence_one_of is not None: _query_params.append(('licenceOneOf', licence_one_of)) if language_one_of is not None: _query_params.append(('languageOneOf', language_one_of)) if nsfw is not None: _query_params.append(('nsfw', nsfw)) if is_local is not None: _query_params.append(('isLocal', is_local)) if include is not None: _query_params.append(('include', include)) if privacy_one_of is not None: _query_params.append(('privacyOneOf', privacy_one_of.value)) if has_hls_files is not None: _query_params.append(('hasHLSFiles', has_hls_files)) if has_web_video_files is not None: _query_params.append(('hasWebVideoFiles', has_web_video_files)) if skip_count is not None: _query_params.append(('skipCount', skip_count)) if start is not None: _query_params.append(('start', start)) if count is not None: _query_params.append(('count', count)) if sort is not None: _query_params.append(('sort', sort)) if exclude_already_watched is not None: _query_params.append(('excludeAlreadyWatched', exclude_already_watched)) # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/videos', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def list_video_storyboards( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ListVideoStoryboards200Response: """List storyboards of a video **PeerTube** >= 6.0 :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._list_video_storyboards_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "ListVideoStoryboards200Response", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def list_video_storyboards_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[ListVideoStoryboards200Response]: """List storyboards of a video **PeerTube** >= 6.0 :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._list_video_storyboards_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "ListVideoStoryboards200Response", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def list_video_storyboards_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """List storyboards of a video **PeerTube** >= 6.0 :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._list_video_storyboards_serialize( id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "ListVideoStoryboards200Response", } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _list_video_storyboards_serialize( self, id, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ ] return self.api_client.param_serialize( method='GET', resource_path='/api/v1/videos/{id}/storyboards', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def put_video( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], thumbnailfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video thumbnail file")] = None, previewfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video preview file")] = None, category: Annotated[Optional[StrictInt], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, licence: Annotated[Optional[StrictInt], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language: Annotated[Optional[StrictStr], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages))")] = None, privacy: Optional[VideoPrivacySet] = None, description: Annotated[Optional[StrictStr], Field(description="Video description")] = None, wait_transcoding: Annotated[Optional[StrictStr], Field(description="Whether or not we wait transcoding before publish the video")] = None, support: Annotated[Optional[StrictStr], Field(description="A text tell the audience how to support the video creator")] = None, nsfw: Annotated[Optional[StrictBool], Field(description="Whether or not this video contains sensitive content")] = None, name: Annotated[Optional[Annotated[str, Field(min_length=3, strict=True, max_length=120)]], Field(description="Video name")] = None, tags: Annotated[Optional[Annotated[List[Annotated[str, Field(min_length=2, strict=True, max_length=30)]], Field(min_length=1, max_length=5)]], Field(description="Video tags (maximum 5 tags each between 2 and 30 characters)")] = None, comments_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable comments for this video")] = None, download_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable downloading for this video")] = None, originally_published_at: Annotated[Optional[datetime], Field(description="Date when the content was originally published")] = None, schedule_update: Optional[VideoScheduledUpdate] = None, video_passwords: Optional[List[Annotated[str, Field(min_length=6, strict=True, max_length=255)]]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Update a video :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param thumbnailfile: Video thumbnail file :type thumbnailfile: bytearray :param previewfile: Video preview file :type previewfile: bytearray :param category: category id of the video (see [/videos/categories](#operation/getCategories)) :type category: int :param licence: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence: int :param language: language id of the video (see [/videos/languages](#operation/getLanguages)) :type language: str :param privacy: :type privacy: VideoPrivacySet :param description: Video description :type description: str :param wait_transcoding: Whether or not we wait transcoding before publish the video :type wait_transcoding: str :param support: A text tell the audience how to support the video creator :type support: str :param nsfw: Whether or not this video contains sensitive content :type nsfw: bool :param name: Video name :type name: str :param tags: Video tags (maximum 5 tags each between 2 and 30 characters) :type tags: List[str] :param comments_enabled: Enable or disable comments for this video :type comments_enabled: bool :param download_enabled: Enable or disable downloading for this video :type download_enabled: bool :param originally_published_at: Date when the content was originally published :type originally_published_at: datetime :param schedule_update: :type schedule_update: VideoScheduledUpdate :param video_passwords: :type video_passwords: List[str] :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._put_video_serialize( id=id, thumbnailfile=thumbnailfile, previewfile=previewfile, category=category, licence=licence, language=language, privacy=privacy, description=description, wait_transcoding=wait_transcoding, support=support, nsfw=nsfw, name=name, tags=tags, comments_enabled=comments_enabled, download_enabled=download_enabled, originally_published_at=originally_published_at, schedule_update=schedule_update, video_passwords=video_passwords, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def put_video_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], thumbnailfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video thumbnail file")] = None, previewfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video preview file")] = None, category: Annotated[Optional[StrictInt], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, licence: Annotated[Optional[StrictInt], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language: Annotated[Optional[StrictStr], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages))")] = None, privacy: Optional[VideoPrivacySet] = None, description: Annotated[Optional[StrictStr], Field(description="Video description")] = None, wait_transcoding: Annotated[Optional[StrictStr], Field(description="Whether or not we wait transcoding before publish the video")] = None, support: Annotated[Optional[StrictStr], Field(description="A text tell the audience how to support the video creator")] = None, nsfw: Annotated[Optional[StrictBool], Field(description="Whether or not this video contains sensitive content")] = None, name: Annotated[Optional[Annotated[str, Field(min_length=3, strict=True, max_length=120)]], Field(description="Video name")] = None, tags: Annotated[Optional[Annotated[List[Annotated[str, Field(min_length=2, strict=True, max_length=30)]], Field(min_length=1, max_length=5)]], Field(description="Video tags (maximum 5 tags each between 2 and 30 characters)")] = None, comments_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable comments for this video")] = None, download_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable downloading for this video")] = None, originally_published_at: Annotated[Optional[datetime], Field(description="Date when the content was originally published")] = None, schedule_update: Optional[VideoScheduledUpdate] = None, video_passwords: Optional[List[Annotated[str, Field(min_length=6, strict=True, max_length=255)]]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Update a video :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param thumbnailfile: Video thumbnail file :type thumbnailfile: bytearray :param previewfile: Video preview file :type previewfile: bytearray :param category: category id of the video (see [/videos/categories](#operation/getCategories)) :type category: int :param licence: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence: int :param language: language id of the video (see [/videos/languages](#operation/getLanguages)) :type language: str :param privacy: :type privacy: VideoPrivacySet :param description: Video description :type description: str :param wait_transcoding: Whether or not we wait transcoding before publish the video :type wait_transcoding: str :param support: A text tell the audience how to support the video creator :type support: str :param nsfw: Whether or not this video contains sensitive content :type nsfw: bool :param name: Video name :type name: str :param tags: Video tags (maximum 5 tags each between 2 and 30 characters) :type tags: List[str] :param comments_enabled: Enable or disable comments for this video :type comments_enabled: bool :param download_enabled: Enable or disable downloading for this video :type download_enabled: bool :param originally_published_at: Date when the content was originally published :type originally_published_at: datetime :param schedule_update: :type schedule_update: VideoScheduledUpdate :param video_passwords: :type video_passwords: List[str] :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._put_video_serialize( id=id, thumbnailfile=thumbnailfile, previewfile=previewfile, category=category, licence=licence, language=language, privacy=privacy, description=description, wait_transcoding=wait_transcoding, support=support, nsfw=nsfw, name=name, tags=tags, comments_enabled=comments_enabled, download_enabled=download_enabled, originally_published_at=originally_published_at, schedule_update=schedule_update, video_passwords=video_passwords, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def put_video_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], thumbnailfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video thumbnail file")] = None, previewfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video preview file")] = None, category: Annotated[Optional[StrictInt], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, licence: Annotated[Optional[StrictInt], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language: Annotated[Optional[StrictStr], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages))")] = None, privacy: Optional[VideoPrivacySet] = None, description: Annotated[Optional[StrictStr], Field(description="Video description")] = None, wait_transcoding: Annotated[Optional[StrictStr], Field(description="Whether or not we wait transcoding before publish the video")] = None, support: Annotated[Optional[StrictStr], Field(description="A text tell the audience how to support the video creator")] = None, nsfw: Annotated[Optional[StrictBool], Field(description="Whether or not this video contains sensitive content")] = None, name: Annotated[Optional[Annotated[str, Field(min_length=3, strict=True, max_length=120)]], Field(description="Video name")] = None, tags: Annotated[Optional[Annotated[List[Annotated[str, Field(min_length=2, strict=True, max_length=30)]], Field(min_length=1, max_length=5)]], Field(description="Video tags (maximum 5 tags each between 2 and 30 characters)")] = None, comments_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable comments for this video")] = None, download_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable downloading for this video")] = None, originally_published_at: Annotated[Optional[datetime], Field(description="Date when the content was originally published")] = None, schedule_update: Optional[VideoScheduledUpdate] = None, video_passwords: Optional[List[Annotated[str, Field(min_length=6, strict=True, max_length=255)]]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Update a video :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param thumbnailfile: Video thumbnail file :type thumbnailfile: bytearray :param previewfile: Video preview file :type previewfile: bytearray :param category: category id of the video (see [/videos/categories](#operation/getCategories)) :type category: int :param licence: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence: int :param language: language id of the video (see [/videos/languages](#operation/getLanguages)) :type language: str :param privacy: :type privacy: VideoPrivacySet :param description: Video description :type description: str :param wait_transcoding: Whether or not we wait transcoding before publish the video :type wait_transcoding: str :param support: A text tell the audience how to support the video creator :type support: str :param nsfw: Whether or not this video contains sensitive content :type nsfw: bool :param name: Video name :type name: str :param tags: Video tags (maximum 5 tags each between 2 and 30 characters) :type tags: List[str] :param comments_enabled: Enable or disable comments for this video :type comments_enabled: bool :param download_enabled: Enable or disable downloading for this video :type download_enabled: bool :param originally_published_at: Date when the content was originally published :type originally_published_at: datetime :param schedule_update: :type schedule_update: VideoScheduledUpdate :param video_passwords: :type video_passwords: List[str] :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._put_video_serialize( id=id, thumbnailfile=thumbnailfile, previewfile=previewfile, category=category, licence=licence, language=language, privacy=privacy, description=description, wait_transcoding=wait_transcoding, support=support, nsfw=nsfw, name=name, tags=tags, comments_enabled=comments_enabled, download_enabled=download_enabled, originally_published_at=originally_published_at, schedule_update=schedule_update, video_passwords=video_passwords, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _put_video_serialize( self, id, thumbnailfile, previewfile, category, licence, language, privacy, description, wait_transcoding, support, nsfw, name, tags, comments_enabled, download_enabled, originally_published_at, schedule_update, video_passwords, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { 'tags': 'csv', 'videoPasswords': 'csv', } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters # process the form parameters if thumbnailfile is not None: _files['thumbnailfile'] = thumbnailfile if previewfile is not None: _files['previewfile'] = previewfile if category is not None: _form_params.append(('category', category)) if licence is not None: _form_params.append(('licence', licence)) if language is not None: _form_params.append(('language', language)) if privacy is not None: _form_params.append(('privacy', privacy)) if description is not None: _form_params.append(('description', description)) if wait_transcoding is not None: _form_params.append(('waitTranscoding', wait_transcoding)) if support is not None: _form_params.append(('support', support)) if nsfw is not None: _form_params.append(('nsfw', nsfw)) if name is not None: _form_params.append(('name', name)) if tags is not None: _form_params.append(('tags', tags)) if comments_enabled is not None: _form_params.append(('commentsEnabled', comments_enabled)) if download_enabled is not None: _form_params.append(('downloadEnabled', download_enabled)) if originally_published_at is not None: _form_params.append(('originallyPublishedAt', originally_published_at)) if schedule_update is not None: _form_params.append(('scheduleUpdate', schedule_update)) if video_passwords is not None: _form_params.append(('videoPasswords', video_passwords)) # process the body parameter # set the HTTP header `Content-Type` if _content_type: _header_params['Content-Type'] = _content_type else: _default_content_type = ( self.api_client.select_header_content_type( [ 'multipart/form-data' ] ) ) if _default_content_type is not None: _header_params['Content-Type'] = _default_content_type # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='PUT', resource_path='/api/v1/videos/{id}', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def replace_video_source_resumable( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_range: Annotated[StrictStr, Field(description="Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. ")], content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. ")], body: Optional[Union[StrictBytes, StrictStr]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Send chunk for the resumable replacement of a video **PeerTube >= 6.0** Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to continue, pause or resume the replacement of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_range: Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. (required) :type content_range: str :param content_length: Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. (required) :type content_length: float :param body: :type body: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._replace_video_source_resumable_serialize( upload_id=upload_id, content_range=content_range, content_length=content_length, body=body, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '308': None, '403': None, '404': None, '409': None, '422': None, '429': None, '503': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def replace_video_source_resumable_with_http_info( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_range: Annotated[StrictStr, Field(description="Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. ")], content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. ")], body: Optional[Union[StrictBytes, StrictStr]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Send chunk for the resumable replacement of a video **PeerTube >= 6.0** Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to continue, pause or resume the replacement of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_range: Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. (required) :type content_range: str :param content_length: Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. (required) :type content_length: float :param body: :type body: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._replace_video_source_resumable_serialize( upload_id=upload_id, content_range=content_range, content_length=content_length, body=body, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '308': None, '403': None, '404': None, '409': None, '422': None, '429': None, '503': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def replace_video_source_resumable_without_preload_content( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_range: Annotated[StrictStr, Field(description="Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. ")], content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. ")], body: Optional[Union[StrictBytes, StrictStr]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Send chunk for the resumable replacement of a video **PeerTube >= 6.0** Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to continue, pause or resume the replacement of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_range: Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. (required) :type content_range: str :param content_length: Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. (required) :type content_length: float :param body: :type body: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._replace_video_source_resumable_serialize( upload_id=upload_id, content_range=content_range, content_length=content_length, body=body, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '308': None, '403': None, '404': None, '409': None, '422': None, '429': None, '503': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _replace_video_source_resumable_serialize( self, upload_id, content_range, content_length, body, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters if upload_id is not None: _query_params.append(('upload_id', upload_id)) # process the header parameters if content_range is not None: _header_params['Content-Range'] = content_range if content_length is not None: _header_params['Content-Length'] = content_length # process the form parameters # process the body parameter if body is not None: # convert to byte array if the input is a file name (str) if isinstance(body, str): with open(body, "rb") as _fp: _body_params = _fp.read() else: _body_params = body # set the HTTP header `Content-Type` if _content_type: _header_params['Content-Type'] = _content_type else: _default_content_type = ( self.api_client.select_header_content_type( [ 'application/octet-stream' ] ) ) if _default_content_type is not None: _header_params['Content-Type'] = _default_content_type # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='PUT', resource_path='/api/v1/videos/{id}/source/replace-resumable', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def replace_video_source_resumable_cancel( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_length: Union[StrictFloat, StrictInt], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Cancel the resumable replacement of a video **PeerTube >= 6.0** Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to cancel the replacement of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_length: (required) :type content_length: float :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._replace_video_source_resumable_cancel_serialize( upload_id=upload_id, content_length=content_length, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def replace_video_source_resumable_cancel_with_http_info( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_length: Union[StrictFloat, StrictInt], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Cancel the resumable replacement of a video **PeerTube >= 6.0** Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to cancel the replacement of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_length: (required) :type content_length: float :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._replace_video_source_resumable_cancel_serialize( upload_id=upload_id, content_length=content_length, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def replace_video_source_resumable_cancel_without_preload_content( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_length: Union[StrictFloat, StrictInt], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Cancel the resumable replacement of a video **PeerTube >= 6.0** Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to cancel the replacement of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_length: (required) :type content_length: float :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._replace_video_source_resumable_cancel_serialize( upload_id=upload_id, content_length=content_length, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _replace_video_source_resumable_cancel_serialize( self, upload_id, content_length, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters if upload_id is not None: _query_params.append(('upload_id', upload_id)) # process the header parameters if content_length is not None: _header_params['Content-Length'] = content_length # process the form parameters # process the body parameter # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='DELETE', resource_path='/api/v1/videos/{id}/source/replace-resumable', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def replace_video_source_resumable_init( self, x_upload_content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading.")], x_upload_content_type: Annotated[StrictStr, Field(description="MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary.")], video_replace_source_request_resumable: Optional[VideoReplaceSourceRequestResumable] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Initialize the resumable replacement of a video **PeerTube >= 6.0** Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to initialize the replacement of a video :param x_upload_content_length: Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading. (required) :type x_upload_content_length: float :param x_upload_content_type: MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary. (required) :type x_upload_content_type: str :param video_replace_source_request_resumable: :type video_replace_source_request_resumable: VideoReplaceSourceRequestResumable :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._replace_video_source_resumable_init_serialize( x_upload_content_length=x_upload_content_length, x_upload_content_type=x_upload_content_type, video_replace_source_request_resumable=video_replace_source_request_resumable, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': None, '201': None, '413': None, '415': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def replace_video_source_resumable_init_with_http_info( self, x_upload_content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading.")], x_upload_content_type: Annotated[StrictStr, Field(description="MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary.")], video_replace_source_request_resumable: Optional[VideoReplaceSourceRequestResumable] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Initialize the resumable replacement of a video **PeerTube >= 6.0** Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to initialize the replacement of a video :param x_upload_content_length: Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading. (required) :type x_upload_content_length: float :param x_upload_content_type: MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary. (required) :type x_upload_content_type: str :param video_replace_source_request_resumable: :type video_replace_source_request_resumable: VideoReplaceSourceRequestResumable :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._replace_video_source_resumable_init_serialize( x_upload_content_length=x_upload_content_length, x_upload_content_type=x_upload_content_type, video_replace_source_request_resumable=video_replace_source_request_resumable, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': None, '201': None, '413': None, '415': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def replace_video_source_resumable_init_without_preload_content( self, x_upload_content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading.")], x_upload_content_type: Annotated[StrictStr, Field(description="MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary.")], video_replace_source_request_resumable: Optional[VideoReplaceSourceRequestResumable] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Initialize the resumable replacement of a video **PeerTube >= 6.0** Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to initialize the replacement of a video :param x_upload_content_length: Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading. (required) :type x_upload_content_length: float :param x_upload_content_type: MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary. (required) :type x_upload_content_type: str :param video_replace_source_request_resumable: :type video_replace_source_request_resumable: VideoReplaceSourceRequestResumable :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._replace_video_source_resumable_init_serialize( x_upload_content_length=x_upload_content_length, x_upload_content_type=x_upload_content_type, video_replace_source_request_resumable=video_replace_source_request_resumable, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': None, '201': None, '413': None, '415': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _replace_video_source_resumable_init_serialize( self, x_upload_content_length, x_upload_content_type, video_replace_source_request_resumable, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters if x_upload_content_length is not None: _header_params['X-Upload-Content-Length'] = x_upload_content_length if x_upload_content_type is not None: _header_params['X-Upload-Content-Type'] = x_upload_content_type # process the form parameters # process the body parameter if video_replace_source_request_resumable is not None: _body_params = video_replace_source_request_resumable # set the HTTP header `Content-Type` if _content_type: _header_params['Content-Type'] = _content_type else: _default_content_type = ( self.api_client.select_header_content_type( [ 'application/json' ] ) ) if _default_content_type is not None: _header_params['Content-Type'] = _default_content_type # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='POST', resource_path='/api/v1/videos/{id}/source/replace-resumable', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def request_video_token( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], x_peertube_video_password: Annotated[Optional[StrictStr], Field(description="Required on password protected video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> VideoTokenResponse: """Request video token Request special tokens that expire quickly to use them in some context (like accessing private static files) :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param x_peertube_video_password: Required on password protected video :type x_peertube_video_password: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._request_video_token_serialize( id=id, x_peertube_video_password=x_peertube_video_password, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoTokenResponse", '400': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def request_video_token_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], x_peertube_video_password: Annotated[Optional[StrictStr], Field(description="Required on password protected video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[VideoTokenResponse]: """Request video token Request special tokens that expire quickly to use them in some context (like accessing private static files) :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param x_peertube_video_password: Required on password protected video :type x_peertube_video_password: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._request_video_token_serialize( id=id, x_peertube_video_password=x_peertube_video_password, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoTokenResponse", '400': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def request_video_token_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], x_peertube_video_password: Annotated[Optional[StrictStr], Field(description="Required on password protected video")] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Request video token Request special tokens that expire quickly to use them in some context (like accessing private static files) :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param x_peertube_video_password: Required on password protected video :type x_peertube_video_password: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._request_video_token_serialize( id=id, x_peertube_video_password=x_peertube_video_password, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoTokenResponse", '400': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _request_video_token_serialize( self, id, x_peertube_video_password, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters if x_peertube_video_password is not None: _header_params['x-peertube-video-password'] = x_peertube_video_password # process the form parameters # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='POST', resource_path='/api/v1/videos/{id}/token', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def update_live_id( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], live_video_update: Optional[LiveVideoUpdate] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Update information about a live :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param live_video_update: :type live_video_update: LiveVideoUpdate :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._update_live_id_serialize( id=id, live_video_update=live_video_update, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '400': None, '403': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def update_live_id_with_http_info( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], live_video_update: Optional[LiveVideoUpdate] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Update information about a live :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param live_video_update: :type live_video_update: LiveVideoUpdate :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._update_live_id_serialize( id=id, live_video_update=live_video_update, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '400': None, '403': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def update_live_id_without_preload_content( self, id: Annotated[Any, Field(description="The object id, uuid or short uuid")], live_video_update: Optional[LiveVideoUpdate] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Update information about a live :param id: The object id, uuid or short uuid (required) :type id: ApiV1VideosOwnershipIdAcceptPostIdParameter :param live_video_update: :type live_video_update: LiveVideoUpdate :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._update_live_id_serialize( id=id, live_video_update=live_video_update, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '400': None, '403': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _update_live_id_serialize( self, id, live_video_update, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters if id is not None: _path_params['id'] = id # process the query parameters # process the header parameters # process the form parameters # process the body parameter if live_video_update is not None: _body_params = live_video_update # set the HTTP header `Content-Type` if _content_type: _header_params['Content-Type'] = _content_type else: _default_content_type = ( self.api_client.select_header_content_type( [ 'application/json' ] ) ) if _default_content_type is not None: _header_params['Content-Type'] = _default_content_type # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='PUT', resource_path='/api/v1/videos/live/{id}', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def upload_legacy( self, name: Annotated[str, Field(min_length=3, strict=True, max_length=120, description="Video name")], videofile: Annotated[Union[StrictBytes, StrictStr], Field(description="Video file")], channel_id: Annotated[Optional[Annotated[int, Field(strict=True, ge=1)]], Field(description="Channel id that will contain this video")] = None, privacy: Optional[VideoPrivacySet] = None, category: Annotated[Optional[StrictInt], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, licence: Annotated[Optional[StrictInt], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language: Annotated[Optional[StrictStr], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages))")] = None, description: Annotated[Optional[StrictStr], Field(description="Video description")] = None, wait_transcoding: Annotated[Optional[StrictBool], Field(description="Whether or not we wait transcoding before publish the video")] = None, support: Annotated[Optional[StrictStr], Field(description="A text tell the audience how to support the video creator")] = None, nsfw: Annotated[Optional[StrictBool], Field(description="Whether or not this video contains sensitive content")] = None, tags: Annotated[Optional[Annotated[List[Annotated[str, Field(min_length=2, strict=True, max_length=30)]], Field(min_length=1, max_length=5)]], Field(description="Video tags (maximum 5 tags each between 2 and 30 characters)")] = None, comments_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable comments for this video")] = None, download_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable downloading for this video")] = None, originally_published_at: Annotated[Optional[datetime], Field(description="Date when the content was originally published")] = None, schedule_update: Optional[VideoScheduledUpdate] = None, thumbnailfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video thumbnail file")] = None, previewfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video preview file")] = None, video_passwords: Optional[List[Annotated[str, Field(min_length=6, strict=True, max_length=255)]]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> VideoUploadResponse: """Upload a video Uses a single request to upload a video. :param name: Video name (required) :type name: str :param videofile: Video file (required) :type videofile: bytearray :param channel_id: Channel id that will contain this video :type channel_id: int :param privacy: :type privacy: VideoPrivacySet :param category: category id of the video (see [/videos/categories](#operation/getCategories)) :type category: int :param licence: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence: int :param language: language id of the video (see [/videos/languages](#operation/getLanguages)) :type language: str :param description: Video description :type description: str :param wait_transcoding: Whether or not we wait transcoding before publish the video :type wait_transcoding: bool :param support: A text tell the audience how to support the video creator :type support: str :param nsfw: Whether or not this video contains sensitive content :type nsfw: bool :param tags: Video tags (maximum 5 tags each between 2 and 30 characters) :type tags: List[str] :param comments_enabled: Enable or disable comments for this video :type comments_enabled: bool :param download_enabled: Enable or disable downloading for this video :type download_enabled: bool :param originally_published_at: Date when the content was originally published :type originally_published_at: datetime :param schedule_update: :type schedule_update: VideoScheduledUpdate :param thumbnailfile: Video thumbnail file :type thumbnailfile: bytearray :param previewfile: Video preview file :type previewfile: bytearray :param video_passwords: :type video_passwords: List[str] :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_legacy_serialize( name=name, videofile=videofile, channel_id=channel_id, privacy=privacy, category=category, licence=licence, language=language, description=description, wait_transcoding=wait_transcoding, support=support, nsfw=nsfw, tags=tags, comments_enabled=comments_enabled, download_enabled=download_enabled, originally_published_at=originally_published_at, schedule_update=schedule_update, thumbnailfile=thumbnailfile, previewfile=previewfile, video_passwords=video_passwords, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoUploadResponse", '403': None, '408': None, '413': None, '415': None, '422': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def upload_legacy_with_http_info( self, name: Annotated[str, Field(min_length=3, strict=True, max_length=120, description="Video name")], videofile: Annotated[Union[StrictBytes, StrictStr], Field(description="Video file")], channel_id: Annotated[Optional[Annotated[int, Field(strict=True, ge=1)]], Field(description="Channel id that will contain this video")] = None, privacy: Optional[VideoPrivacySet] = None, category: Annotated[Optional[StrictInt], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, licence: Annotated[Optional[StrictInt], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language: Annotated[Optional[StrictStr], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages))")] = None, description: Annotated[Optional[StrictStr], Field(description="Video description")] = None, wait_transcoding: Annotated[Optional[StrictBool], Field(description="Whether or not we wait transcoding before publish the video")] = None, support: Annotated[Optional[StrictStr], Field(description="A text tell the audience how to support the video creator")] = None, nsfw: Annotated[Optional[StrictBool], Field(description="Whether or not this video contains sensitive content")] = None, tags: Annotated[Optional[Annotated[List[Annotated[str, Field(min_length=2, strict=True, max_length=30)]], Field(min_length=1, max_length=5)]], Field(description="Video tags (maximum 5 tags each between 2 and 30 characters)")] = None, comments_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable comments for this video")] = None, download_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable downloading for this video")] = None, originally_published_at: Annotated[Optional[datetime], Field(description="Date when the content was originally published")] = None, schedule_update: Optional[VideoScheduledUpdate] = None, thumbnailfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video thumbnail file")] = None, previewfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video preview file")] = None, video_passwords: Optional[List[Annotated[str, Field(min_length=6, strict=True, max_length=255)]]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[VideoUploadResponse]: """Upload a video Uses a single request to upload a video. :param name: Video name (required) :type name: str :param videofile: Video file (required) :type videofile: bytearray :param channel_id: Channel id that will contain this video :type channel_id: int :param privacy: :type privacy: VideoPrivacySet :param category: category id of the video (see [/videos/categories](#operation/getCategories)) :type category: int :param licence: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence: int :param language: language id of the video (see [/videos/languages](#operation/getLanguages)) :type language: str :param description: Video description :type description: str :param wait_transcoding: Whether or not we wait transcoding before publish the video :type wait_transcoding: bool :param support: A text tell the audience how to support the video creator :type support: str :param nsfw: Whether or not this video contains sensitive content :type nsfw: bool :param tags: Video tags (maximum 5 tags each between 2 and 30 characters) :type tags: List[str] :param comments_enabled: Enable or disable comments for this video :type comments_enabled: bool :param download_enabled: Enable or disable downloading for this video :type download_enabled: bool :param originally_published_at: Date when the content was originally published :type originally_published_at: datetime :param schedule_update: :type schedule_update: VideoScheduledUpdate :param thumbnailfile: Video thumbnail file :type thumbnailfile: bytearray :param previewfile: Video preview file :type previewfile: bytearray :param video_passwords: :type video_passwords: List[str] :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_legacy_serialize( name=name, videofile=videofile, channel_id=channel_id, privacy=privacy, category=category, licence=licence, language=language, description=description, wait_transcoding=wait_transcoding, support=support, nsfw=nsfw, tags=tags, comments_enabled=comments_enabled, download_enabled=download_enabled, originally_published_at=originally_published_at, schedule_update=schedule_update, thumbnailfile=thumbnailfile, previewfile=previewfile, video_passwords=video_passwords, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoUploadResponse", '403': None, '408': None, '413': None, '415': None, '422': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def upload_legacy_without_preload_content( self, name: Annotated[str, Field(min_length=3, strict=True, max_length=120, description="Video name")], videofile: Annotated[Union[StrictBytes, StrictStr], Field(description="Video file")], channel_id: Annotated[Optional[Annotated[int, Field(strict=True, ge=1)]], Field(description="Channel id that will contain this video")] = None, privacy: Optional[VideoPrivacySet] = None, category: Annotated[Optional[StrictInt], Field(description="category id of the video (see [/videos/categories](#operation/getCategories))")] = None, licence: Annotated[Optional[StrictInt], Field(description="licence id of the video (see [/videos/licences](#operation/getLicences))")] = None, language: Annotated[Optional[StrictStr], Field(description="language id of the video (see [/videos/languages](#operation/getLanguages))")] = None, description: Annotated[Optional[StrictStr], Field(description="Video description")] = None, wait_transcoding: Annotated[Optional[StrictBool], Field(description="Whether or not we wait transcoding before publish the video")] = None, support: Annotated[Optional[StrictStr], Field(description="A text tell the audience how to support the video creator")] = None, nsfw: Annotated[Optional[StrictBool], Field(description="Whether or not this video contains sensitive content")] = None, tags: Annotated[Optional[Annotated[List[Annotated[str, Field(min_length=2, strict=True, max_length=30)]], Field(min_length=1, max_length=5)]], Field(description="Video tags (maximum 5 tags each between 2 and 30 characters)")] = None, comments_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable comments for this video")] = None, download_enabled: Annotated[Optional[StrictBool], Field(description="Enable or disable downloading for this video")] = None, originally_published_at: Annotated[Optional[datetime], Field(description="Date when the content was originally published")] = None, schedule_update: Optional[VideoScheduledUpdate] = None, thumbnailfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video thumbnail file")] = None, previewfile: Annotated[Optional[Union[StrictBytes, StrictStr]], Field(description="Video preview file")] = None, video_passwords: Optional[List[Annotated[str, Field(min_length=6, strict=True, max_length=255)]]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Upload a video Uses a single request to upload a video. :param name: Video name (required) :type name: str :param videofile: Video file (required) :type videofile: bytearray :param channel_id: Channel id that will contain this video :type channel_id: int :param privacy: :type privacy: VideoPrivacySet :param category: category id of the video (see [/videos/categories](#operation/getCategories)) :type category: int :param licence: licence id of the video (see [/videos/licences](#operation/getLicences)) :type licence: int :param language: language id of the video (see [/videos/languages](#operation/getLanguages)) :type language: str :param description: Video description :type description: str :param wait_transcoding: Whether or not we wait transcoding before publish the video :type wait_transcoding: bool :param support: A text tell the audience how to support the video creator :type support: str :param nsfw: Whether or not this video contains sensitive content :type nsfw: bool :param tags: Video tags (maximum 5 tags each between 2 and 30 characters) :type tags: List[str] :param comments_enabled: Enable or disable comments for this video :type comments_enabled: bool :param download_enabled: Enable or disable downloading for this video :type download_enabled: bool :param originally_published_at: Date when the content was originally published :type originally_published_at: datetime :param schedule_update: :type schedule_update: VideoScheduledUpdate :param thumbnailfile: Video thumbnail file :type thumbnailfile: bytearray :param previewfile: Video preview file :type previewfile: bytearray :param video_passwords: :type video_passwords: List[str] :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_legacy_serialize( name=name, videofile=videofile, channel_id=channel_id, privacy=privacy, category=category, licence=licence, language=language, description=description, wait_transcoding=wait_transcoding, support=support, nsfw=nsfw, tags=tags, comments_enabled=comments_enabled, download_enabled=download_enabled, originally_published_at=originally_published_at, schedule_update=schedule_update, thumbnailfile=thumbnailfile, previewfile=previewfile, video_passwords=video_passwords, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoUploadResponse", '403': None, '408': None, '413': None, '415': None, '422': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _upload_legacy_serialize( self, name, videofile, channel_id, privacy, category, licence, language, description, wait_transcoding, support, nsfw, tags, comments_enabled, download_enabled, originally_published_at, schedule_update, thumbnailfile, previewfile, video_passwords, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { 'tags': 'csv', 'videoPasswords': 'csv', } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters # process the form parameters if name is not None: _form_params.append(('name', name)) if channel_id is not None: _form_params.append(('channelId', channel_id)) if privacy is not None: _form_params.append(('privacy', privacy)) if category is not None: _form_params.append(('category', category)) if licence is not None: _form_params.append(('licence', licence)) if language is not None: _form_params.append(('language', language)) if description is not None: _form_params.append(('description', description)) if wait_transcoding is not None: _form_params.append(('waitTranscoding', wait_transcoding)) if support is not None: _form_params.append(('support', support)) if nsfw is not None: _form_params.append(('nsfw', nsfw)) if tags is not None: _form_params.append(('tags', tags)) if comments_enabled is not None: _form_params.append(('commentsEnabled', comments_enabled)) if download_enabled is not None: _form_params.append(('downloadEnabled', download_enabled)) if originally_published_at is not None: _form_params.append(('originallyPublishedAt', originally_published_at)) if schedule_update is not None: _form_params.append(('scheduleUpdate', schedule_update)) if thumbnailfile is not None: _files['thumbnailfile'] = thumbnailfile if previewfile is not None: _files['previewfile'] = previewfile if video_passwords is not None: _form_params.append(('videoPasswords', video_passwords)) if videofile is not None: _files['videofile'] = videofile # process the body parameter # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # set the HTTP header `Content-Type` if _content_type: _header_params['Content-Type'] = _content_type else: _default_content_type = ( self.api_client.select_header_content_type( [ 'multipart/form-data' ] ) ) if _default_content_type is not None: _header_params['Content-Type'] = _default_content_type # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='POST', resource_path='/api/v1/videos/upload', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def upload_resumable( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_range: Annotated[StrictStr, Field(description="Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. ")], content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. ")], body: Optional[Union[StrictBytes, StrictStr]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> VideoUploadResponse: """Send chunk for the resumable upload of a video Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to continue, pause or resume the upload of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_range: Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. (required) :type content_range: str :param content_length: Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. (required) :type content_length: float :param body: :type body: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_resumable_serialize( upload_id=upload_id, content_range=content_range, content_length=content_length, body=body, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoUploadResponse", '308': None, '403': None, '404': None, '409': None, '422': None, '429': None, '503': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def upload_resumable_with_http_info( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_range: Annotated[StrictStr, Field(description="Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. ")], content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. ")], body: Optional[Union[StrictBytes, StrictStr]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[VideoUploadResponse]: """Send chunk for the resumable upload of a video Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to continue, pause or resume the upload of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_range: Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. (required) :type content_range: str :param content_length: Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. (required) :type content_length: float :param body: :type body: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_resumable_serialize( upload_id=upload_id, content_range=content_range, content_length=content_length, body=body, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoUploadResponse", '308': None, '403': None, '404': None, '409': None, '422': None, '429': None, '503': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def upload_resumable_without_preload_content( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_range: Annotated[StrictStr, Field(description="Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. ")], content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. ")], body: Optional[Union[StrictBytes, StrictStr]] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Send chunk for the resumable upload of a video Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to continue, pause or resume the upload of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_range: Specifies the bytes in the file that the request is uploading. For example, a value of `bytes 0-262143/1000000` shows that the request is sending the first 262144 bytes (256 x 1024) in a 2,469,036 byte file. (required) :type content_range: str :param content_length: Size of the chunk that the request is sending. Remember that larger chunks are more efficient. PeerTube's web client uses chunks varying from 1048576 bytes (~1MB) and increases or reduces size depending on connection health. (required) :type content_length: float :param body: :type body: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_resumable_serialize( upload_id=upload_id, content_range=content_range, content_length=content_length, body=body, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoUploadResponse", '308': None, '403': None, '404': None, '409': None, '422': None, '429': None, '503': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _upload_resumable_serialize( self, upload_id, content_range, content_length, body, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters if upload_id is not None: _query_params.append(('upload_id', upload_id)) # process the header parameters if content_range is not None: _header_params['Content-Range'] = content_range if content_length is not None: _header_params['Content-Length'] = content_length # process the form parameters # process the body parameter if body is not None: # convert to byte array if the input is a file name (str) if isinstance(body, str): with open(body, "rb") as _fp: _body_params = _fp.read() else: _body_params = body # set the HTTP header `Accept` _header_params['Accept'] = self.api_client.select_header_accept( [ 'application/json' ] ) # set the HTTP header `Content-Type` if _content_type: _header_params['Content-Type'] = _content_type else: _default_content_type = ( self.api_client.select_header_content_type( [ 'application/octet-stream' ] ) ) if _default_content_type is not None: _header_params['Content-Type'] = _default_content_type # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='PUT', resource_path='/api/v1/videos/upload-resumable', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def upload_resumable_cancel( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_length: Union[StrictFloat, StrictInt], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Cancel the resumable upload of a video, deleting any data uploaded so far Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to cancel the upload of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_length: (required) :type content_length: float :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_resumable_cancel_serialize( upload_id=upload_id, content_length=content_length, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def upload_resumable_cancel_with_http_info( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_length: Union[StrictFloat, StrictInt], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Cancel the resumable upload of a video, deleting any data uploaded so far Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to cancel the upload of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_length: (required) :type content_length: float :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_resumable_cancel_serialize( upload_id=upload_id, content_length=content_length, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def upload_resumable_cancel_without_preload_content( self, upload_id: Annotated[StrictStr, Field(description="Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. ")], content_length: Union[StrictFloat, StrictInt], _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Cancel the resumable upload of a video, deleting any data uploaded so far Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to cancel the upload of a video :param upload_id: Created session id to proceed with. If you didn't send chunks in the last hour, it is not valid anymore and you need to initialize a new upload. (required) :type upload_id: str :param content_length: (required) :type content_length: float :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_resumable_cancel_serialize( upload_id=upload_id, content_length=content_length, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '204': None, '404': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _upload_resumable_cancel_serialize( self, upload_id, content_length, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters if upload_id is not None: _query_params.append(('upload_id', upload_id)) # process the header parameters if content_length is not None: _header_params['Content-Length'] = content_length # process the form parameters # process the body parameter # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='DELETE', resource_path='/api/v1/videos/upload-resumable', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth ) @validate_call def upload_resumable_init( self, x_upload_content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading.")], x_upload_content_type: Annotated[StrictStr, Field(description="MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary.")], video_upload_request_resumable: Optional[VideoUploadRequestResumable] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: """Initialize the resumable upload of a video Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to initialize the upload of a video :param x_upload_content_length: Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading. (required) :type x_upload_content_length: float :param x_upload_content_type: MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary. (required) :type x_upload_content_type: str :param video_upload_request_resumable: :type video_upload_request_resumable: VideoUploadRequestResumable :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_resumable_init_serialize( x_upload_content_length=x_upload_content_length, x_upload_content_type=x_upload_content_type, video_upload_request_resumable=video_upload_request_resumable, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': None, '201': None, '413': None, '415': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ).data @validate_call def upload_resumable_init_with_http_info( self, x_upload_content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading.")], x_upload_content_type: Annotated[StrictStr, Field(description="MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary.")], video_upload_request_resumable: Optional[VideoUploadRequestResumable] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> ApiResponse[None]: """Initialize the resumable upload of a video Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to initialize the upload of a video :param x_upload_content_length: Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading. (required) :type x_upload_content_length: float :param x_upload_content_type: MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary. (required) :type x_upload_content_type: str :param video_upload_request_resumable: :type video_upload_request_resumable: VideoUploadRequestResumable :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_resumable_init_serialize( x_upload_content_length=x_upload_content_length, x_upload_content_type=x_upload_content_type, video_upload_request_resumable=video_upload_request_resumable, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': None, '201': None, '413': None, '415': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) response_data.read() return self.api_client.response_deserialize( response_data=response_data, response_types_map=_response_types_map, ) @validate_call def upload_resumable_init_without_preload_content( self, x_upload_content_length: Annotated[Union[StrictFloat, StrictInt], Field(description="Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading.")], x_upload_content_type: Annotated[StrictStr, Field(description="MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary.")], video_upload_request_resumable: Optional[VideoUploadRequestResumable] = None, _request_timeout: Union[ None, Annotated[StrictFloat, Field(gt=0)], Tuple[ Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)] ] ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> RESTResponseType: """Initialize the resumable upload of a video Uses [a resumable protocol](https://github.com/kukhariev/node-uploadx/blob/master/proto.md) to initialize the upload of a video :param x_upload_content_length: Number of bytes that will be uploaded in subsequent requests. Set this value to the size of the file you are uploading. (required) :type x_upload_content_length: float :param x_upload_content_type: MIME type of the file that you are uploading. Depending on your instance settings, acceptable values might vary. (required) :type x_upload_content_type: str :param video_upload_request_resumable: :type video_upload_request_resumable: VideoUploadRequestResumable :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object. """ # noqa: E501 _param = self._upload_resumable_init_serialize( x_upload_content_length=x_upload_content_length, x_upload_content_type=x_upload_content_type, video_upload_request_resumable=video_upload_request_resumable, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': None, '201': None, '413': None, '415': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _upload_resumable_init_serialize( self, x_upload_content_length, x_upload_content_type, video_upload_request_resumable, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { } _path_params: Dict[str, str] = {} _query_params: List[Tuple[str, str]] = [] _header_params: Dict[str, Optional[str]] = _headers or {} _form_params: List[Tuple[str, str]] = [] _files: Dict[str, str] = {} _body_params: Optional[bytes] = None # process the path parameters # process the query parameters # process the header parameters if x_upload_content_length is not None: _header_params['X-Upload-Content-Length'] = x_upload_content_length if x_upload_content_type is not None: _header_params['X-Upload-Content-Type'] = x_upload_content_type # process the form parameters # process the body parameter if video_upload_request_resumable is not None: _body_params = video_upload_request_resumable # set the HTTP header `Content-Type` if _content_type: _header_params['Content-Type'] = _content_type else: _default_content_type = ( self.api_client.select_header_content_type( [ 'application/json' ] ) ) if _default_content_type is not None: _header_params['Content-Type'] = _default_content_type # authentication setting _auth_settings: List[str] = [ 'OAuth2' ] return self.api_client.param_serialize( method='POST', resource_path='/api/v1/videos/upload-resumable', path_params=_path_params, query_params=_query_params, header_params=_header_params, body=_body_params, post_params=_form_params, files=_files, auth_settings=_auth_settings, collection_formats=_collection_formats, _host=_host, _request_auth=_request_auth )