# 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, StrictInt, StrictStr, field_validator from typing import Any, List, Optional from typing_extensions import Annotated from peertube.models.api_v1_video_channels_channel_handle_video_playlists_get200_response import ApiV1VideoChannelsChannelHandleVideoPlaylistsGet200Response from peertube.models.video_channel_list import VideoChannelList from peertube.models.video_list_response import VideoListResponse from peertube.models.video_privacy_set import VideoPrivacySet from peertube.api_client import ApiClient, RequestSerialized from peertube.api_response import ApiResponse from peertube.rest import RESTResponseType class SearchApi: """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 search_channels( self, search: Annotated[StrictStr, Field(description="String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete channel information and interact with it. ")], 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, search_target: Annotated[Optional[StrictStr], Field(description="If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API ")] = None, sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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, ) -> VideoChannelList: """Search channels :param search: String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete channel information and interact with it. (required) :type search: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param search_target: If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API :type search_target: str :param sort: Sort column :type sort: 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._search_channels_serialize( search=search, start=start, count=count, search_target=search_target, sort=sort, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoChannelList", '500': 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 search_channels_with_http_info( self, search: Annotated[StrictStr, Field(description="String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete channel information and interact with it. ")], 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, search_target: Annotated[Optional[StrictStr], Field(description="If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API ")] = None, sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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[VideoChannelList]: """Search channels :param search: String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete channel information and interact with it. (required) :type search: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param search_target: If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API :type search_target: str :param sort: Sort column :type sort: 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._search_channels_serialize( search=search, start=start, count=count, search_target=search_target, sort=sort, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoChannelList", '500': 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 search_channels_without_preload_content( self, search: Annotated[StrictStr, Field(description="String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete channel information and interact with it. ")], 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, search_target: Annotated[Optional[StrictStr], Field(description="If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API ")] = None, sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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: """Search channels :param search: String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete channel information and interact with it. (required) :type search: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param search_target: If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API :type search_target: str :param sort: Sort column :type sort: 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._search_channels_serialize( search=search, start=start, count=count, search_target=search_target, sort=sort, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoChannelList", '500': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _search_channels_serialize( self, search, start, count, search_target, sort, _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 search is not None: _query_params.append(('search', search)) if start is not None: _query_params.append(('start', start)) if count is not None: _query_params.append(('count', count)) if search_target is not None: _query_params.append(('searchTarget', search_target)) if sort is not None: _query_params.append(('sort', sort)) # 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/search/video-channels', 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 search_playlists( self, search: Annotated[StrictStr, Field(description="String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete playlist information and interact with it. ")], 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, search_target: Annotated[Optional[StrictStr], Field(description="If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API ")] = None, sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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, ) -> ApiV1VideoChannelsChannelHandleVideoPlaylistsGet200Response: """Search playlists :param search: String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete playlist information and interact with it. (required) :type search: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param search_target: If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API :type search_target: str :param sort: Sort column :type sort: 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._search_playlists_serialize( search=search, start=start, count=count, search_target=search_target, sort=sort, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "ApiV1VideoChannelsChannelHandleVideoPlaylistsGet200Response", '500': 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 search_playlists_with_http_info( self, search: Annotated[StrictStr, Field(description="String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete playlist information and interact with it. ")], 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, search_target: Annotated[Optional[StrictStr], Field(description="If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API ")] = None, sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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[ApiV1VideoChannelsChannelHandleVideoPlaylistsGet200Response]: """Search playlists :param search: String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete playlist information and interact with it. (required) :type search: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param search_target: If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API :type search_target: str :param sort: Sort column :type sort: 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._search_playlists_serialize( search=search, start=start, count=count, search_target=search_target, sort=sort, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "ApiV1VideoChannelsChannelHandleVideoPlaylistsGet200Response", '500': 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 search_playlists_without_preload_content( self, search: Annotated[StrictStr, Field(description="String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete playlist information and interact with it. ")], 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, search_target: Annotated[Optional[StrictStr], Field(description="If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API ")] = None, sort: Annotated[Optional[StrictStr], Field(description="Sort column")] = 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: """Search playlists :param search: String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete playlist information and interact with it. (required) :type search: str :param start: Offset used to paginate results :type start: int :param count: Number of items to return :type count: int :param search_target: If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API :type search_target: str :param sort: Sort column :type sort: 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._search_playlists_serialize( search=search, start=start, count=count, search_target=search_target, sort=sort, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "ApiV1VideoChannelsChannelHandleVideoPlaylistsGet200Response", '500': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _search_playlists_serialize( self, search, start, count, search_target, sort, _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 search is not None: _query_params.append(('search', search)) if start is not None: _query_params.append(('start', start)) if count is not None: _query_params.append(('count', count)) if search_target is not None: _query_params.append(('searchTarget', search_target)) if sort is not None: _query_params.append(('sort', sort)) # 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/search/video-playlists', 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 search_videos( self, search: Annotated[StrictStr, Field(description="String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete video information and interact with it. ")], 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, uuids: Annotated[Optional[List[StrictStr]], Field(description="Find videos with specific UUIDs")] = 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, search_target: Annotated[Optional[StrictStr], Field(description="If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API ")] = None, sort: Annotated[Optional[StrictStr], Field(description="Sort videos by criteria (prefixing with `-` means `DESC` order): ")] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, start_date: Annotated[Optional[datetime], Field(description="Get videos that are published after this date")] = None, end_date: Annotated[Optional[datetime], Field(description="Get videos that are published before this date")] = None, originally_published_start_date: Annotated[Optional[datetime], Field(description="Get videos that are originally published after this date")] = None, originally_published_end_date: Annotated[Optional[datetime], Field(description="Get videos that are originally published before this date")] = None, duration_min: Annotated[Optional[StrictInt], Field(description="Get videos that have this minimum duration")] = None, duration_max: Annotated[Optional[StrictInt], Field(description="Get videos that have this maximum duration")] = 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: """Search videos :param search: String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete video information and interact with it. (required) :type search: 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 uuids: Find videos with specific UUIDs :type uuids: List[str] :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 search_target: If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API :type search_target: str :param sort: Sort videos by criteria (prefixing with `-` means `DESC` order): :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 start_date: Get videos that are published after this date :type start_date: datetime :param end_date: Get videos that are published before this date :type end_date: datetime :param originally_published_start_date: Get videos that are originally published after this date :type originally_published_start_date: datetime :param originally_published_end_date: Get videos that are originally published before this date :type originally_published_end_date: datetime :param duration_min: Get videos that have this minimum duration :type duration_min: int :param duration_max: Get videos that have this maximum duration :type duration_max: int :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._search_videos_serialize( search=search, 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, uuids=uuids, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, search_target=search_target, sort=sort, exclude_already_watched=exclude_already_watched, start_date=start_date, end_date=end_date, originally_published_start_date=originally_published_start_date, originally_published_end_date=originally_published_end_date, duration_min=duration_min, duration_max=duration_max, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", '500': 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 search_videos_with_http_info( self, search: Annotated[StrictStr, Field(description="String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete video information and interact with it. ")], 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, uuids: Annotated[Optional[List[StrictStr]], Field(description="Find videos with specific UUIDs")] = 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, search_target: Annotated[Optional[StrictStr], Field(description="If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API ")] = None, sort: Annotated[Optional[StrictStr], Field(description="Sort videos by criteria (prefixing with `-` means `DESC` order): ")] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, start_date: Annotated[Optional[datetime], Field(description="Get videos that are published after this date")] = None, end_date: Annotated[Optional[datetime], Field(description="Get videos that are published before this date")] = None, originally_published_start_date: Annotated[Optional[datetime], Field(description="Get videos that are originally published after this date")] = None, originally_published_end_date: Annotated[Optional[datetime], Field(description="Get videos that are originally published before this date")] = None, duration_min: Annotated[Optional[StrictInt], Field(description="Get videos that have this minimum duration")] = None, duration_max: Annotated[Optional[StrictInt], Field(description="Get videos that have this maximum duration")] = 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]: """Search videos :param search: String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete video information and interact with it. (required) :type search: 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 uuids: Find videos with specific UUIDs :type uuids: List[str] :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 search_target: If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API :type search_target: str :param sort: Sort videos by criteria (prefixing with `-` means `DESC` order): :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 start_date: Get videos that are published after this date :type start_date: datetime :param end_date: Get videos that are published before this date :type end_date: datetime :param originally_published_start_date: Get videos that are originally published after this date :type originally_published_start_date: datetime :param originally_published_end_date: Get videos that are originally published before this date :type originally_published_end_date: datetime :param duration_min: Get videos that have this minimum duration :type duration_min: int :param duration_max: Get videos that have this maximum duration :type duration_max: int :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._search_videos_serialize( search=search, 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, uuids=uuids, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, search_target=search_target, sort=sort, exclude_already_watched=exclude_already_watched, start_date=start_date, end_date=end_date, originally_published_start_date=originally_published_start_date, originally_published_end_date=originally_published_end_date, duration_min=duration_min, duration_max=duration_max, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", '500': 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 search_videos_without_preload_content( self, search: Annotated[StrictStr, Field(description="String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete video information and interact with it. ")], 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, uuids: Annotated[Optional[List[StrictStr]], Field(description="Find videos with specific UUIDs")] = 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, search_target: Annotated[Optional[StrictStr], Field(description="If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API ")] = None, sort: Annotated[Optional[StrictStr], Field(description="Sort videos by criteria (prefixing with `-` means `DESC` order): ")] = None, exclude_already_watched: Annotated[Optional[StrictBool], Field(description="Whether or not to exclude videos that are in the user's video history")] = None, start_date: Annotated[Optional[datetime], Field(description="Get videos that are published after this date")] = None, end_date: Annotated[Optional[datetime], Field(description="Get videos that are published before this date")] = None, originally_published_start_date: Annotated[Optional[datetime], Field(description="Get videos that are originally published after this date")] = None, originally_published_end_date: Annotated[Optional[datetime], Field(description="Get videos that are originally published before this date")] = None, duration_min: Annotated[Optional[StrictInt], Field(description="Get videos that have this minimum duration")] = None, duration_max: Annotated[Optional[StrictInt], Field(description="Get videos that have this maximum duration")] = 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: """Search videos :param search: String to search. If the user can make a remote URI search, and the string is an URI then the PeerTube instance will fetch the remote object and add it to its database. Then, you can use the REST API to fetch the complete video information and interact with it. (required) :type search: 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 uuids: Find videos with specific UUIDs :type uuids: List[str] :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 search_target: If the administrator enabled search index support, you can override the default search target. **Warning**: If you choose to make an index search, PeerTube will get results from a third party service. It means the instance may not yet know the objects you fetched. If you want to load video/channel information: * If the current user has the ability to make a remote URI search (this information is available in the config endpoint), then reuse the search API to make a search using the object URI so PeerTube instance fetches the remote object and fill its database. After that, you can use the classic REST API endpoints to fetch the complete object or interact with it * If the current user doesn't have the ability to make a remote URI search, then redirect the user on the origin instance or fetch the data from the origin instance API :type search_target: str :param sort: Sort videos by criteria (prefixing with `-` means `DESC` order): :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 start_date: Get videos that are published after this date :type start_date: datetime :param end_date: Get videos that are published before this date :type end_date: datetime :param originally_published_start_date: Get videos that are originally published after this date :type originally_published_start_date: datetime :param originally_published_end_date: Get videos that are originally published before this date :type originally_published_end_date: datetime :param duration_min: Get videos that have this minimum duration :type duration_min: int :param duration_max: Get videos that have this maximum duration :type duration_max: int :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._search_videos_serialize( search=search, 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, uuids=uuids, has_hls_files=has_hls_files, has_web_video_files=has_web_video_files, skip_count=skip_count, start=start, count=count, search_target=search_target, sort=sort, exclude_already_watched=exclude_already_watched, start_date=start_date, end_date=end_date, originally_published_start_date=originally_published_start_date, originally_published_end_date=originally_published_end_date, duration_min=duration_min, duration_max=duration_max, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index ) _response_types_map: Dict[str, Optional[str]] = { '200': "VideoListResponse", '500': None, } response_data = self.api_client.call_api( *_param, _request_timeout=_request_timeout ) return response_data.response def _search_videos_serialize( self, search, category_one_of, is_live, tags_one_of, tags_all_of, licence_one_of, language_one_of, nsfw, is_local, include, privacy_one_of, uuids, has_hls_files, has_web_video_files, skip_count, start, count, search_target, sort, exclude_already_watched, start_date, end_date, originally_published_start_date, originally_published_end_date, duration_min, duration_max, _request_auth, _content_type, _headers, _host_index, ) -> RequestSerialized: _host = None _collection_formats: Dict[str, str] = { 'uuids': 'multi', } _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 search is not None: _query_params.append(('search', search)) 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 uuids is not None: _query_params.append(('uuids', uuids)) 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 search_target is not None: _query_params.append(('searchTarget', search_target)) if sort is not None: _query_params.append(('sort', sort)) if exclude_already_watched is not None: _query_params.append(('excludeAlreadyWatched', exclude_already_watched)) if start_date is not None: if isinstance(start_date, datetime): _query_params.append( ( 'startDate', start_date.strftime( self.api_client.configuration.datetime_format ) ) ) else: _query_params.append(('startDate', start_date)) if end_date is not None: if isinstance(end_date, datetime): _query_params.append( ( 'endDate', end_date.strftime( self.api_client.configuration.datetime_format ) ) ) else: _query_params.append(('endDate', end_date)) if originally_published_start_date is not None: if isinstance(originally_published_start_date, datetime): _query_params.append( ( 'originallyPublishedStartDate', originally_published_start_date.strftime( self.api_client.configuration.datetime_format ) ) ) else: _query_params.append(('originallyPublishedStartDate', originally_published_start_date)) if originally_published_end_date is not None: if isinstance(originally_published_end_date, datetime): _query_params.append( ( 'originallyPublishedEndDate', originally_published_end_date.strftime( self.api_client.configuration.datetime_format ) ) ) else: _query_params.append(('originallyPublishedEndDate', originally_published_end_date)) if duration_min is not None: _query_params.append(('durationMin', duration_min)) if duration_max is not None: _query_params.append(('durationMax', duration_max)) # 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/search/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 )