1512 lines
73 KiB
Python
1512 lines
73 KiB
Python
# 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.<field>.location` can be either 'params', 'body', 'header', 'query' or 'cookies', and `invalid-params.<field>.value` reports the value that didn't pass validation whose `invalid-params.<field>.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<sup>*</sup> | 5 minutes | | `POST /users/ask-send-verify-email` | 3 | 5 minutes | Depending on the endpoint, <sup>*</sup>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 pydantic import Field, StrictBool, StrictInt, StrictStr, field_validator
|
|
from typing import Optional
|
|
from typing_extensions import Annotated
|
|
from peertube.models.video_comments_for_xml_inner import VideoCommentsForXMLInner
|
|
from peertube.models.video_privacy_set import VideoPrivacySet
|
|
from peertube.models.videos_for_xml_inner import VideosForXMLInner
|
|
|
|
from peertube.api_client import ApiClient, RequestSerialized
|
|
from peertube.api_response import ApiResponse
|
|
from peertube.rest import RESTResponseType
|
|
|
|
|
|
class VideoFeedsApi:
|
|
"""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 get_syndicated_comments(
|
|
self,
|
|
format: Annotated[StrictStr, Field(description="format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss))")],
|
|
video_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video")] = None,
|
|
account_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
account_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
video_channel_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = None,
|
|
video_channel_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = 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,
|
|
) -> List[VideoCommentsForXMLInner]:
|
|
"""Comments on videos feeds
|
|
|
|
|
|
:param format: format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss)) (required)
|
|
:type format: str
|
|
:param video_id: limit listing to a specific video
|
|
:type video_id: str
|
|
:param account_id: limit listing to a specific account
|
|
:type account_id: str
|
|
:param account_name: limit listing to a specific account
|
|
:type account_name: str
|
|
:param video_channel_id: limit listing to a specific video channel
|
|
:type video_channel_id: str
|
|
:param video_channel_name: limit listing to a specific video channel
|
|
:type video_channel_name: 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_syndicated_comments_serialize(
|
|
format=format,
|
|
video_id=video_id,
|
|
account_id=account_id,
|
|
account_name=account_name,
|
|
video_channel_id=video_channel_id,
|
|
video_channel_name=video_channel_name,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[VideoCommentsForXMLInner]",
|
|
'400': None,
|
|
'404': None,
|
|
'406': 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_syndicated_comments_with_http_info(
|
|
self,
|
|
format: Annotated[StrictStr, Field(description="format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss))")],
|
|
video_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video")] = None,
|
|
account_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
account_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
video_channel_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = None,
|
|
video_channel_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = 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[List[VideoCommentsForXMLInner]]:
|
|
"""Comments on videos feeds
|
|
|
|
|
|
:param format: format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss)) (required)
|
|
:type format: str
|
|
:param video_id: limit listing to a specific video
|
|
:type video_id: str
|
|
:param account_id: limit listing to a specific account
|
|
:type account_id: str
|
|
:param account_name: limit listing to a specific account
|
|
:type account_name: str
|
|
:param video_channel_id: limit listing to a specific video channel
|
|
:type video_channel_id: str
|
|
:param video_channel_name: limit listing to a specific video channel
|
|
:type video_channel_name: 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_syndicated_comments_serialize(
|
|
format=format,
|
|
video_id=video_id,
|
|
account_id=account_id,
|
|
account_name=account_name,
|
|
video_channel_id=video_channel_id,
|
|
video_channel_name=video_channel_name,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[VideoCommentsForXMLInner]",
|
|
'400': None,
|
|
'404': None,
|
|
'406': 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_syndicated_comments_without_preload_content(
|
|
self,
|
|
format: Annotated[StrictStr, Field(description="format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss))")],
|
|
video_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video")] = None,
|
|
account_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
account_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
video_channel_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = None,
|
|
video_channel_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = 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:
|
|
"""Comments on videos feeds
|
|
|
|
|
|
:param format: format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss)) (required)
|
|
:type format: str
|
|
:param video_id: limit listing to a specific video
|
|
:type video_id: str
|
|
:param account_id: limit listing to a specific account
|
|
:type account_id: str
|
|
:param account_name: limit listing to a specific account
|
|
:type account_name: str
|
|
:param video_channel_id: limit listing to a specific video channel
|
|
:type video_channel_id: str
|
|
:param video_channel_name: limit listing to a specific video channel
|
|
:type video_channel_name: 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_syndicated_comments_serialize(
|
|
format=format,
|
|
video_id=video_id,
|
|
account_id=account_id,
|
|
account_name=account_name,
|
|
video_channel_id=video_channel_id,
|
|
video_channel_name=video_channel_name,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[VideoCommentsForXMLInner]",
|
|
'400': None,
|
|
'404': None,
|
|
'406': None,
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _get_syndicated_comments_serialize(
|
|
self,
|
|
format,
|
|
video_id,
|
|
account_id,
|
|
account_name,
|
|
video_channel_id,
|
|
video_channel_name,
|
|
_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 format is not None:
|
|
_path_params['format'] = format
|
|
# process the query parameters
|
|
if video_id is not None:
|
|
|
|
_query_params.append(('videoId', video_id))
|
|
|
|
if account_id is not None:
|
|
|
|
_query_params.append(('accountId', account_id))
|
|
|
|
if account_name is not None:
|
|
|
|
_query_params.append(('accountName', account_name))
|
|
|
|
if video_channel_id is not None:
|
|
|
|
_query_params.append(('videoChannelId', video_channel_id))
|
|
|
|
if video_channel_name is not None:
|
|
|
|
_query_params.append(('videoChannelName', video_channel_name))
|
|
|
|
# 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/xml',
|
|
'application/rss+xml',
|
|
'text/xml',
|
|
'application/atom+xml',
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='GET',
|
|
resource_path='/feeds/video-comments.{format}',
|
|
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_syndicated_subscription_videos(
|
|
self,
|
|
format: Annotated[StrictStr, Field(description="format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss))")],
|
|
account_id: Annotated[StrictStr, Field(description="limit listing to a specific account")],
|
|
token: Annotated[StrictStr, Field(description="private token allowing access")],
|
|
sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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,
|
|
_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[VideosForXMLInner]:
|
|
"""Videos of subscriptions feeds
|
|
|
|
|
|
:param format: format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss)) (required)
|
|
:type format: str
|
|
:param account_id: limit listing to a specific account (required)
|
|
:type account_id: str
|
|
:param token: private token allowing access (required)
|
|
:type token: str
|
|
:param sort: Sort column
|
|
:type sort: str
|
|
: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 _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_syndicated_subscription_videos_serialize(
|
|
format=format,
|
|
account_id=account_id,
|
|
token=token,
|
|
sort=sort,
|
|
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,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[VideosForXMLInner]",
|
|
'406': 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_syndicated_subscription_videos_with_http_info(
|
|
self,
|
|
format: Annotated[StrictStr, Field(description="format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss))")],
|
|
account_id: Annotated[StrictStr, Field(description="limit listing to a specific account")],
|
|
token: Annotated[StrictStr, Field(description="private token allowing access")],
|
|
sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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,
|
|
_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[VideosForXMLInner]]:
|
|
"""Videos of subscriptions feeds
|
|
|
|
|
|
:param format: format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss)) (required)
|
|
:type format: str
|
|
:param account_id: limit listing to a specific account (required)
|
|
:type account_id: str
|
|
:param token: private token allowing access (required)
|
|
:type token: str
|
|
:param sort: Sort column
|
|
:type sort: str
|
|
: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 _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_syndicated_subscription_videos_serialize(
|
|
format=format,
|
|
account_id=account_id,
|
|
token=token,
|
|
sort=sort,
|
|
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,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[VideosForXMLInner]",
|
|
'406': 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_syndicated_subscription_videos_without_preload_content(
|
|
self,
|
|
format: Annotated[StrictStr, Field(description="format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss))")],
|
|
account_id: Annotated[StrictStr, Field(description="limit listing to a specific account")],
|
|
token: Annotated[StrictStr, Field(description="private token allowing access")],
|
|
sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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,
|
|
_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:
|
|
"""Videos of subscriptions feeds
|
|
|
|
|
|
:param format: format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss)) (required)
|
|
:type format: str
|
|
:param account_id: limit listing to a specific account (required)
|
|
:type account_id: str
|
|
:param token: private token allowing access (required)
|
|
:type token: str
|
|
:param sort: Sort column
|
|
:type sort: str
|
|
: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 _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_syndicated_subscription_videos_serialize(
|
|
format=format,
|
|
account_id=account_id,
|
|
token=token,
|
|
sort=sort,
|
|
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,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[VideosForXMLInner]",
|
|
'406': None,
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _get_syndicated_subscription_videos_serialize(
|
|
self,
|
|
format,
|
|
account_id,
|
|
token,
|
|
sort,
|
|
nsfw,
|
|
is_local,
|
|
include,
|
|
privacy_one_of,
|
|
has_hls_files,
|
|
has_web_video_files,
|
|
_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 format is not None:
|
|
_path_params['format'] = format
|
|
# process the query parameters
|
|
if account_id is not None:
|
|
|
|
_query_params.append(('accountId', account_id))
|
|
|
|
if token is not None:
|
|
|
|
_query_params.append(('token', token))
|
|
|
|
if sort is not None:
|
|
|
|
_query_params.append(('sort', sort))
|
|
|
|
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))
|
|
|
|
# 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/xml',
|
|
'application/rss+xml',
|
|
'text/xml',
|
|
'application/atom+xml',
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='GET',
|
|
resource_path='/feeds/subscriptions.{format}',
|
|
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_syndicated_videos(
|
|
self,
|
|
format: Annotated[StrictStr, Field(description="format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss))")],
|
|
account_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
account_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
video_channel_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = None,
|
|
video_channel_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = None,
|
|
sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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,
|
|
_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[VideosForXMLInner]:
|
|
"""Common videos feeds
|
|
|
|
|
|
:param format: format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss)) (required)
|
|
:type format: str
|
|
:param account_id: limit listing to a specific account
|
|
:type account_id: str
|
|
:param account_name: limit listing to a specific account
|
|
:type account_name: str
|
|
:param video_channel_id: limit listing to a specific video channel
|
|
:type video_channel_id: str
|
|
:param video_channel_name: limit listing to a specific video channel
|
|
:type video_channel_name: str
|
|
:param sort: Sort column
|
|
:type sort: str
|
|
: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 _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_syndicated_videos_serialize(
|
|
format=format,
|
|
account_id=account_id,
|
|
account_name=account_name,
|
|
video_channel_id=video_channel_id,
|
|
video_channel_name=video_channel_name,
|
|
sort=sort,
|
|
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,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[VideosForXMLInner]",
|
|
'404': None,
|
|
'406': 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_syndicated_videos_with_http_info(
|
|
self,
|
|
format: Annotated[StrictStr, Field(description="format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss))")],
|
|
account_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
account_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
video_channel_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = None,
|
|
video_channel_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = None,
|
|
sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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,
|
|
_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[VideosForXMLInner]]:
|
|
"""Common videos feeds
|
|
|
|
|
|
:param format: format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss)) (required)
|
|
:type format: str
|
|
:param account_id: limit listing to a specific account
|
|
:type account_id: str
|
|
:param account_name: limit listing to a specific account
|
|
:type account_name: str
|
|
:param video_channel_id: limit listing to a specific video channel
|
|
:type video_channel_id: str
|
|
:param video_channel_name: limit listing to a specific video channel
|
|
:type video_channel_name: str
|
|
:param sort: Sort column
|
|
:type sort: str
|
|
: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 _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_syndicated_videos_serialize(
|
|
format=format,
|
|
account_id=account_id,
|
|
account_name=account_name,
|
|
video_channel_id=video_channel_id,
|
|
video_channel_name=video_channel_name,
|
|
sort=sort,
|
|
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,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[VideosForXMLInner]",
|
|
'404': None,
|
|
'406': 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_syndicated_videos_without_preload_content(
|
|
self,
|
|
format: Annotated[StrictStr, Field(description="format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss))")],
|
|
account_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
account_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific account")] = None,
|
|
video_channel_id: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = None,
|
|
video_channel_name: Annotated[Optional[StrictStr], Field(description="limit listing to a specific video channel")] = None,
|
|
sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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,
|
|
_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:
|
|
"""Common videos feeds
|
|
|
|
|
|
:param format: format expected (we focus on making `rss` the most featureful ; it serves [Media RSS](https://www.rssboard.org/media-rss)) (required)
|
|
:type format: str
|
|
:param account_id: limit listing to a specific account
|
|
:type account_id: str
|
|
:param account_name: limit listing to a specific account
|
|
:type account_name: str
|
|
:param video_channel_id: limit listing to a specific video channel
|
|
:type video_channel_id: str
|
|
:param video_channel_name: limit listing to a specific video channel
|
|
:type video_channel_name: str
|
|
:param sort: Sort column
|
|
:type sort: str
|
|
: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 _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_syndicated_videos_serialize(
|
|
format=format,
|
|
account_id=account_id,
|
|
account_name=account_name,
|
|
video_channel_id=video_channel_id,
|
|
video_channel_name=video_channel_name,
|
|
sort=sort,
|
|
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,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[VideosForXMLInner]",
|
|
'404': None,
|
|
'406': None,
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _get_syndicated_videos_serialize(
|
|
self,
|
|
format,
|
|
account_id,
|
|
account_name,
|
|
video_channel_id,
|
|
video_channel_name,
|
|
sort,
|
|
nsfw,
|
|
is_local,
|
|
include,
|
|
privacy_one_of,
|
|
has_hls_files,
|
|
has_web_video_files,
|
|
_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 format is not None:
|
|
_path_params['format'] = format
|
|
# process the query parameters
|
|
if account_id is not None:
|
|
|
|
_query_params.append(('accountId', account_id))
|
|
|
|
if account_name is not None:
|
|
|
|
_query_params.append(('accountName', account_name))
|
|
|
|
if video_channel_id is not None:
|
|
|
|
_query_params.append(('videoChannelId', video_channel_id))
|
|
|
|
if video_channel_name is not None:
|
|
|
|
_query_params.append(('videoChannelName', video_channel_name))
|
|
|
|
if sort is not None:
|
|
|
|
_query_params.append(('sort', sort))
|
|
|
|
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))
|
|
|
|
# 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/xml',
|
|
'application/rss+xml',
|
|
'text/xml',
|
|
'application/atom+xml',
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='GET',
|
|
resource_path='/feeds/videos.{format}',
|
|
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_podcast_feed(
|
|
self,
|
|
video_channel_id: Annotated[StrictStr, Field(description="Limit listing to a specific video channel")],
|
|
_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:
|
|
"""Videos podcast feed
|
|
|
|
|
|
:param video_channel_id: Limit listing to a specific video channel (required)
|
|
:type video_channel_id: 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_videos_podcast_feed_serialize(
|
|
video_channel_id=video_channel_id,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': 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 get_videos_podcast_feed_with_http_info(
|
|
self,
|
|
video_channel_id: Annotated[StrictStr, Field(description="Limit listing to a specific video channel")],
|
|
_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]:
|
|
"""Videos podcast feed
|
|
|
|
|
|
:param video_channel_id: Limit listing to a specific video channel (required)
|
|
:type video_channel_id: 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_videos_podcast_feed_serialize(
|
|
video_channel_id=video_channel_id,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': 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 get_videos_podcast_feed_without_preload_content(
|
|
self,
|
|
video_channel_id: Annotated[StrictStr, Field(description="Limit listing to a specific video channel")],
|
|
_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:
|
|
"""Videos podcast feed
|
|
|
|
|
|
:param video_channel_id: Limit listing to a specific video channel (required)
|
|
:type video_channel_id: 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_videos_podcast_feed_serialize(
|
|
video_channel_id=video_channel_id,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': None,
|
|
'404': None,
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _get_videos_podcast_feed_serialize(
|
|
self,
|
|
video_channel_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
|
|
# process the query parameters
|
|
if video_channel_id is not None:
|
|
|
|
_query_params.append(('videoChannelId', video_channel_id))
|
|
|
|
# process the header parameters
|
|
# process the form parameters
|
|
# process the body parameter
|
|
|
|
|
|
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='GET',
|
|
resource_path='/feeds/podcast/videos.xml',
|
|
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
|
|
)
|
|
|
|
|