3417 lines
135 KiB
Python
3417 lines
135 KiB
Python
# coding: utf-8
|
|
|
|
"""
|
|
Immich
|
|
|
|
Immich API
|
|
|
|
The version of the OpenAPI document: 3.0.1
|
|
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, StrictStr, field_validator
|
|
from typing import List, Optional
|
|
from typing_extensions import Annotated
|
|
from generated.immich.openapi_client.models.asset_response_dto import AssetResponseDto
|
|
from generated.immich.openapi_client.models.asset_type_enum import AssetTypeEnum
|
|
from generated.immich.openapi_client.models.asset_visibility import AssetVisibility
|
|
from generated.immich.openapi_client.models.metadata_search_dto import MetadataSearchDto
|
|
from generated.immich.openapi_client.models.person_response_dto import PersonResponseDto
|
|
from generated.immich.openapi_client.models.places_response_dto import PlacesResponseDto
|
|
from generated.immich.openapi_client.models.random_search_dto import RandomSearchDto
|
|
from generated.immich.openapi_client.models.search_explore_response_dto import SearchExploreResponseDto
|
|
from generated.immich.openapi_client.models.search_response_dto import SearchResponseDto
|
|
from generated.immich.openapi_client.models.search_statistics_response_dto import SearchStatisticsResponseDto
|
|
from generated.immich.openapi_client.models.search_suggestion_type import SearchSuggestionType
|
|
from generated.immich.openapi_client.models.smart_search_dto import SmartSearchDto
|
|
from generated.immich.openapi_client.models.statistics_search_dto import StatisticsSearchDto
|
|
|
|
from generated.immich.openapi_client.api_client import ApiClient, RequestSerialized
|
|
from generated.immich.openapi_client.api_response import ApiResponse
|
|
from generated.immich.openapi_client.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 get_assets_by_city(
|
|
self,
|
|
_request_timeout: Union[
|
|
None,
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Tuple[
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Annotated[StrictFloat, Field(gt=0)]
|
|
]
|
|
] = None,
|
|
_request_auth: Optional[Dict[StrictStr, Any]] = None,
|
|
_content_type: Optional[StrictStr] = None,
|
|
_headers: Optional[Dict[StrictStr, Any]] = None,
|
|
_host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
|
|
) -> List[AssetResponseDto]:
|
|
"""Retrieve assets by city
|
|
|
|
Retrieve a list of assets with each asset belonging to a different city. This endpoint is used on the places pages to show a single thumbnail for each city the user has assets in.
|
|
|
|
: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_assets_by_city_serialize(
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[AssetResponseDto]",
|
|
}
|
|
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_assets_by_city_with_http_info(
|
|
self,
|
|
_request_timeout: Union[
|
|
None,
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Tuple[
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Annotated[StrictFloat, Field(gt=0)]
|
|
]
|
|
] = None,
|
|
_request_auth: Optional[Dict[StrictStr, Any]] = None,
|
|
_content_type: Optional[StrictStr] = None,
|
|
_headers: Optional[Dict[StrictStr, Any]] = None,
|
|
_host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
|
|
) -> ApiResponse[List[AssetResponseDto]]:
|
|
"""Retrieve assets by city
|
|
|
|
Retrieve a list of assets with each asset belonging to a different city. This endpoint is used on the places pages to show a single thumbnail for each city the user has assets in.
|
|
|
|
: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_assets_by_city_serialize(
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[AssetResponseDto]",
|
|
}
|
|
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_assets_by_city_without_preload_content(
|
|
self,
|
|
_request_timeout: Union[
|
|
None,
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Tuple[
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Annotated[StrictFloat, Field(gt=0)]
|
|
]
|
|
] = None,
|
|
_request_auth: Optional[Dict[StrictStr, Any]] = None,
|
|
_content_type: Optional[StrictStr] = None,
|
|
_headers: Optional[Dict[StrictStr, Any]] = None,
|
|
_host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
|
|
) -> RESTResponseType:
|
|
"""Retrieve assets by city
|
|
|
|
Retrieve a list of assets with each asset belonging to a different city. This endpoint is used on the places pages to show a single thumbnail for each city the user has assets in.
|
|
|
|
: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_assets_by_city_serialize(
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[AssetResponseDto]",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _get_assets_by_city_serialize(
|
|
self,
|
|
_request_auth,
|
|
_content_type,
|
|
_headers,
|
|
_host_index,
|
|
) -> RequestSerialized:
|
|
|
|
_host = None
|
|
|
|
_collection_formats: Dict[str, str] = {
|
|
}
|
|
|
|
_path_params: Dict[str, str] = {}
|
|
_query_params: List[Tuple[str, str]] = []
|
|
_header_params: Dict[str, Optional[str]] = _headers or {}
|
|
_form_params: List[Tuple[str, str]] = []
|
|
_files: Dict[
|
|
str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
|
|
] = {}
|
|
_body_params: Optional[bytes] = None
|
|
|
|
# process the path parameters
|
|
# process the query parameters
|
|
# process the header parameters
|
|
# process the form parameters
|
|
# process the body parameter
|
|
|
|
|
|
# set the HTTP header `Accept`
|
|
if 'Accept' not in _header_params:
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
'cookie',
|
|
'api_key',
|
|
'bearer'
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='GET',
|
|
resource_path='/search/cities',
|
|
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_explore_data(
|
|
self,
|
|
_request_timeout: Union[
|
|
None,
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Tuple[
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Annotated[StrictFloat, Field(gt=0)]
|
|
]
|
|
] = None,
|
|
_request_auth: Optional[Dict[StrictStr, Any]] = None,
|
|
_content_type: Optional[StrictStr] = None,
|
|
_headers: Optional[Dict[StrictStr, Any]] = None,
|
|
_host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
|
|
) -> List[SearchExploreResponseDto]:
|
|
"""Retrieve explore data
|
|
|
|
Retrieve data for the explore section, such as popular people and places.
|
|
|
|
: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_explore_data_serialize(
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[SearchExploreResponseDto]",
|
|
}
|
|
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_explore_data_with_http_info(
|
|
self,
|
|
_request_timeout: Union[
|
|
None,
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Tuple[
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Annotated[StrictFloat, Field(gt=0)]
|
|
]
|
|
] = None,
|
|
_request_auth: Optional[Dict[StrictStr, Any]] = None,
|
|
_content_type: Optional[StrictStr] = None,
|
|
_headers: Optional[Dict[StrictStr, Any]] = None,
|
|
_host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
|
|
) -> ApiResponse[List[SearchExploreResponseDto]]:
|
|
"""Retrieve explore data
|
|
|
|
Retrieve data for the explore section, such as popular people and places.
|
|
|
|
: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_explore_data_serialize(
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[SearchExploreResponseDto]",
|
|
}
|
|
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_explore_data_without_preload_content(
|
|
self,
|
|
_request_timeout: Union[
|
|
None,
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Tuple[
|
|
Annotated[StrictFloat, Field(gt=0)],
|
|
Annotated[StrictFloat, Field(gt=0)]
|
|
]
|
|
] = None,
|
|
_request_auth: Optional[Dict[StrictStr, Any]] = None,
|
|
_content_type: Optional[StrictStr] = None,
|
|
_headers: Optional[Dict[StrictStr, Any]] = None,
|
|
_host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
|
|
) -> RESTResponseType:
|
|
"""Retrieve explore data
|
|
|
|
Retrieve data for the explore section, such as popular people and places.
|
|
|
|
: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_explore_data_serialize(
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[SearchExploreResponseDto]",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _get_explore_data_serialize(
|
|
self,
|
|
_request_auth,
|
|
_content_type,
|
|
_headers,
|
|
_host_index,
|
|
) -> RequestSerialized:
|
|
|
|
_host = None
|
|
|
|
_collection_formats: Dict[str, str] = {
|
|
}
|
|
|
|
_path_params: Dict[str, str] = {}
|
|
_query_params: List[Tuple[str, str]] = []
|
|
_header_params: Dict[str, Optional[str]] = _headers or {}
|
|
_form_params: List[Tuple[str, str]] = []
|
|
_files: Dict[
|
|
str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
|
|
] = {}
|
|
_body_params: Optional[bytes] = None
|
|
|
|
# process the path parameters
|
|
# process the query parameters
|
|
# process the header parameters
|
|
# process the form parameters
|
|
# process the body parameter
|
|
|
|
|
|
# set the HTTP header `Accept`
|
|
if 'Accept' not in _header_params:
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
'cookie',
|
|
'api_key',
|
|
'bearer'
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='GET',
|
|
resource_path='/search/explore',
|
|
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_search_suggestions(
|
|
self,
|
|
type: SearchSuggestionType,
|
|
country: Annotated[Optional[StrictStr], Field(description="Filter by country")] = None,
|
|
include_null: Annotated[Optional[StrictBool], Field(description="Include null values in suggestions")] = None,
|
|
lens_model: Annotated[Optional[StrictStr], Field(description="Filter by lens model")] = None,
|
|
make: Annotated[Optional[StrictStr], Field(description="Filter by camera make")] = None,
|
|
model: Annotated[Optional[StrictStr], Field(description="Filter by camera model")] = None,
|
|
state: Annotated[Optional[StrictStr], Field(description="Filter by state/province")] = 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[str]:
|
|
"""Retrieve search suggestions
|
|
|
|
Retrieve search suggestions based on partial input. This endpoint is used for typeahead search features.
|
|
|
|
:param type: (required)
|
|
:type type: SearchSuggestionType
|
|
:param country: Filter by country
|
|
:type country: str
|
|
:param include_null: Include null values in suggestions
|
|
:type include_null: bool
|
|
:param lens_model: Filter by lens model
|
|
:type lens_model: str
|
|
:param make: Filter by camera make
|
|
:type make: str
|
|
:param model: Filter by camera model
|
|
:type model: str
|
|
:param state: Filter by state/province
|
|
:type state: 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_search_suggestions_serialize(
|
|
type=type,
|
|
country=country,
|
|
include_null=include_null,
|
|
lens_model=lens_model,
|
|
make=make,
|
|
model=model,
|
|
state=state,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[str]",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
response_data.read()
|
|
return self.api_client.response_deserialize(
|
|
response_data=response_data,
|
|
response_types_map=_response_types_map,
|
|
).data
|
|
|
|
|
|
@validate_call
|
|
def get_search_suggestions_with_http_info(
|
|
self,
|
|
type: SearchSuggestionType,
|
|
country: Annotated[Optional[StrictStr], Field(description="Filter by country")] = None,
|
|
include_null: Annotated[Optional[StrictBool], Field(description="Include null values in suggestions")] = None,
|
|
lens_model: Annotated[Optional[StrictStr], Field(description="Filter by lens model")] = None,
|
|
make: Annotated[Optional[StrictStr], Field(description="Filter by camera make")] = None,
|
|
model: Annotated[Optional[StrictStr], Field(description="Filter by camera model")] = None,
|
|
state: Annotated[Optional[StrictStr], Field(description="Filter by state/province")] = 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[str]]:
|
|
"""Retrieve search suggestions
|
|
|
|
Retrieve search suggestions based on partial input. This endpoint is used for typeahead search features.
|
|
|
|
:param type: (required)
|
|
:type type: SearchSuggestionType
|
|
:param country: Filter by country
|
|
:type country: str
|
|
:param include_null: Include null values in suggestions
|
|
:type include_null: bool
|
|
:param lens_model: Filter by lens model
|
|
:type lens_model: str
|
|
:param make: Filter by camera make
|
|
:type make: str
|
|
:param model: Filter by camera model
|
|
:type model: str
|
|
:param state: Filter by state/province
|
|
:type state: 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_search_suggestions_serialize(
|
|
type=type,
|
|
country=country,
|
|
include_null=include_null,
|
|
lens_model=lens_model,
|
|
make=make,
|
|
model=model,
|
|
state=state,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[str]",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
response_data.read()
|
|
return self.api_client.response_deserialize(
|
|
response_data=response_data,
|
|
response_types_map=_response_types_map,
|
|
)
|
|
|
|
|
|
@validate_call
|
|
def get_search_suggestions_without_preload_content(
|
|
self,
|
|
type: SearchSuggestionType,
|
|
country: Annotated[Optional[StrictStr], Field(description="Filter by country")] = None,
|
|
include_null: Annotated[Optional[StrictBool], Field(description="Include null values in suggestions")] = None,
|
|
lens_model: Annotated[Optional[StrictStr], Field(description="Filter by lens model")] = None,
|
|
make: Annotated[Optional[StrictStr], Field(description="Filter by camera make")] = None,
|
|
model: Annotated[Optional[StrictStr], Field(description="Filter by camera model")] = None,
|
|
state: Annotated[Optional[StrictStr], Field(description="Filter by state/province")] = 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:
|
|
"""Retrieve search suggestions
|
|
|
|
Retrieve search suggestions based on partial input. This endpoint is used for typeahead search features.
|
|
|
|
:param type: (required)
|
|
:type type: SearchSuggestionType
|
|
:param country: Filter by country
|
|
:type country: str
|
|
:param include_null: Include null values in suggestions
|
|
:type include_null: bool
|
|
:param lens_model: Filter by lens model
|
|
:type lens_model: str
|
|
:param make: Filter by camera make
|
|
:type make: str
|
|
:param model: Filter by camera model
|
|
:type model: str
|
|
:param state: Filter by state/province
|
|
:type state: 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_search_suggestions_serialize(
|
|
type=type,
|
|
country=country,
|
|
include_null=include_null,
|
|
lens_model=lens_model,
|
|
make=make,
|
|
model=model,
|
|
state=state,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[str]",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _get_search_suggestions_serialize(
|
|
self,
|
|
type,
|
|
country,
|
|
include_null,
|
|
lens_model,
|
|
make,
|
|
model,
|
|
state,
|
|
_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, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
|
|
] = {}
|
|
_body_params: Optional[bytes] = None
|
|
|
|
# process the path parameters
|
|
# process the query parameters
|
|
if country is not None:
|
|
|
|
_query_params.append(('country', country))
|
|
|
|
if include_null is not None:
|
|
|
|
_query_params.append(('includeNull', include_null))
|
|
|
|
if lens_model is not None:
|
|
|
|
_query_params.append(('lensModel', lens_model))
|
|
|
|
if make is not None:
|
|
|
|
_query_params.append(('make', make))
|
|
|
|
if model is not None:
|
|
|
|
_query_params.append(('model', model))
|
|
|
|
if state is not None:
|
|
|
|
_query_params.append(('state', state))
|
|
|
|
if type is not None:
|
|
|
|
_query_params.append(('type', type.value))
|
|
|
|
# process the header parameters
|
|
# process the form parameters
|
|
# process the body parameter
|
|
|
|
|
|
# set the HTTP header `Accept`
|
|
if 'Accept' not in _header_params:
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
'cookie',
|
|
'api_key',
|
|
'bearer'
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='GET',
|
|
resource_path='/search/suggestions',
|
|
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_asset_statistics(
|
|
self,
|
|
statistics_search_dto: StatisticsSearchDto,
|
|
_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,
|
|
) -> SearchStatisticsResponseDto:
|
|
"""Search asset statistics
|
|
|
|
Retrieve statistical data about assets based on search criteria, such as the total matching count.
|
|
|
|
:param statistics_search_dto: (required)
|
|
:type statistics_search_dto: StatisticsSearchDto
|
|
: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_asset_statistics_serialize(
|
|
statistics_search_dto=statistics_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "SearchStatisticsResponseDto",
|
|
}
|
|
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_asset_statistics_with_http_info(
|
|
self,
|
|
statistics_search_dto: StatisticsSearchDto,
|
|
_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[SearchStatisticsResponseDto]:
|
|
"""Search asset statistics
|
|
|
|
Retrieve statistical data about assets based on search criteria, such as the total matching count.
|
|
|
|
:param statistics_search_dto: (required)
|
|
:type statistics_search_dto: StatisticsSearchDto
|
|
: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_asset_statistics_serialize(
|
|
statistics_search_dto=statistics_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "SearchStatisticsResponseDto",
|
|
}
|
|
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_asset_statistics_without_preload_content(
|
|
self,
|
|
statistics_search_dto: StatisticsSearchDto,
|
|
_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 asset statistics
|
|
|
|
Retrieve statistical data about assets based on search criteria, such as the total matching count.
|
|
|
|
:param statistics_search_dto: (required)
|
|
:type statistics_search_dto: StatisticsSearchDto
|
|
: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_asset_statistics_serialize(
|
|
statistics_search_dto=statistics_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "SearchStatisticsResponseDto",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _search_asset_statistics_serialize(
|
|
self,
|
|
statistics_search_dto,
|
|
_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, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
|
|
] = {}
|
|
_body_params: Optional[bytes] = None
|
|
|
|
# process the path parameters
|
|
# process the query parameters
|
|
# process the header parameters
|
|
# process the form parameters
|
|
# process the body parameter
|
|
if statistics_search_dto is not None:
|
|
_body_params = statistics_search_dto
|
|
|
|
|
|
# set the HTTP header `Accept`
|
|
if 'Accept' not in _header_params:
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
# set the HTTP header `Content-Type`
|
|
if _content_type:
|
|
_header_params['Content-Type'] = _content_type
|
|
else:
|
|
_default_content_type = (
|
|
self.api_client.select_header_content_type(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
)
|
|
if _default_content_type is not None:
|
|
_header_params['Content-Type'] = _default_content_type
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
'cookie',
|
|
'api_key',
|
|
'bearer'
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='POST',
|
|
resource_path='/search/statistics',
|
|
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_assets(
|
|
self,
|
|
metadata_search_dto: MetadataSearchDto,
|
|
_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,
|
|
) -> SearchResponseDto:
|
|
"""Search assets by metadata
|
|
|
|
Search for assets based on various metadata criteria.
|
|
|
|
:param metadata_search_dto: (required)
|
|
:type metadata_search_dto: MetadataSearchDto
|
|
: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_assets_serialize(
|
|
metadata_search_dto=metadata_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "SearchResponseDto",
|
|
}
|
|
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_assets_with_http_info(
|
|
self,
|
|
metadata_search_dto: MetadataSearchDto,
|
|
_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[SearchResponseDto]:
|
|
"""Search assets by metadata
|
|
|
|
Search for assets based on various metadata criteria.
|
|
|
|
:param metadata_search_dto: (required)
|
|
:type metadata_search_dto: MetadataSearchDto
|
|
: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_assets_serialize(
|
|
metadata_search_dto=metadata_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "SearchResponseDto",
|
|
}
|
|
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_assets_without_preload_content(
|
|
self,
|
|
metadata_search_dto: MetadataSearchDto,
|
|
_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 assets by metadata
|
|
|
|
Search for assets based on various metadata criteria.
|
|
|
|
:param metadata_search_dto: (required)
|
|
:type metadata_search_dto: MetadataSearchDto
|
|
: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_assets_serialize(
|
|
metadata_search_dto=metadata_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "SearchResponseDto",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _search_assets_serialize(
|
|
self,
|
|
metadata_search_dto,
|
|
_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, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
|
|
] = {}
|
|
_body_params: Optional[bytes] = None
|
|
|
|
# process the path parameters
|
|
# process the query parameters
|
|
# process the header parameters
|
|
# process the form parameters
|
|
# process the body parameter
|
|
if metadata_search_dto is not None:
|
|
_body_params = metadata_search_dto
|
|
|
|
|
|
# set the HTTP header `Accept`
|
|
if 'Accept' not in _header_params:
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
# set the HTTP header `Content-Type`
|
|
if _content_type:
|
|
_header_params['Content-Type'] = _content_type
|
|
else:
|
|
_default_content_type = (
|
|
self.api_client.select_header_content_type(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
)
|
|
if _default_content_type is not None:
|
|
_header_params['Content-Type'] = _default_content_type
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
'cookie',
|
|
'api_key',
|
|
'bearer'
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='POST',
|
|
resource_path='/search/metadata',
|
|
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_large_assets(
|
|
self,
|
|
album_ids: Annotated[Optional[List[Annotated[str, Field(strict=True)]]], Field(description="Filter by album IDs")] = None,
|
|
city: Annotated[Optional[StrictStr], Field(description="Filter by city name")] = None,
|
|
country: Annotated[Optional[StrictStr], Field(description="Filter by country name")] = None,
|
|
created_after: Annotated[Optional[datetime], Field(description="Filter by creation date (after)")] = None,
|
|
created_before: Annotated[Optional[datetime], Field(description="Filter by creation date (before)")] = None,
|
|
is_encoded: Annotated[Optional[StrictBool], Field(description="Filter by encoded status")] = None,
|
|
is_favorite: Annotated[Optional[StrictBool], Field(description="Filter by favorite status")] = None,
|
|
is_motion: Annotated[Optional[StrictBool], Field(description="Filter by motion photo status")] = None,
|
|
is_not_in_album: Annotated[Optional[StrictBool], Field(description="Filter assets not in any album")] = None,
|
|
is_offline: Annotated[Optional[StrictBool], Field(description="Filter by offline status")] = None,
|
|
lens_model: Annotated[Optional[StrictStr], Field(description="Filter by lens model")] = None,
|
|
library_id: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Library ID to filter by")] = None,
|
|
make: Annotated[Optional[StrictStr], Field(description="Filter by camera make")] = None,
|
|
min_file_size: Annotated[Optional[Annotated[int, Field(le=9007199254740991, strict=True, ge=0)]], Field(description="Minimum file size in bytes")] = None,
|
|
model: Annotated[Optional[StrictStr], Field(description="Filter by camera model")] = None,
|
|
ocr: Annotated[Optional[StrictStr], Field(description="Filter by OCR text content")] = None,
|
|
person_ids: Annotated[Optional[List[Annotated[str, Field(strict=True)]]], Field(description="Filter by person IDs")] = None,
|
|
rating: Annotated[Optional[Annotated[int, Field(le=5, strict=True, ge=1)]], Field(description="Filter by rating [1-5], or null for unrated")] = None,
|
|
size: Annotated[Optional[Annotated[int, Field(le=1000, strict=True, ge=1)]], Field(description="Number of results to return")] = None,
|
|
state: Annotated[Optional[StrictStr], Field(description="Filter by state/province name")] = None,
|
|
tag_ids: Annotated[Optional[List[Annotated[str, Field(strict=True)]]], Field(description="Filter by tag IDs")] = None,
|
|
taken_after: Annotated[Optional[datetime], Field(description="Filter by taken date (after)")] = None,
|
|
taken_before: Annotated[Optional[datetime], Field(description="Filter by taken date (before)")] = None,
|
|
trashed_after: Annotated[Optional[datetime], Field(description="Filter by trash date (after)")] = None,
|
|
trashed_before: Annotated[Optional[datetime], Field(description="Filter by trash date (before)")] = None,
|
|
type: Optional[AssetTypeEnum] = None,
|
|
updated_after: Annotated[Optional[datetime], Field(description="Filter by update date (after)")] = None,
|
|
updated_before: Annotated[Optional[datetime], Field(description="Filter by update date (before)")] = None,
|
|
visibility: Optional[AssetVisibility] = None,
|
|
with_deleted: Annotated[Optional[StrictBool], Field(description="Include deleted assets")] = None,
|
|
with_exif: Annotated[Optional[StrictBool], Field(description="Include EXIF data in response")] = 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[AssetResponseDto]:
|
|
"""Search large assets
|
|
|
|
Search for assets that are considered large based on specified criteria.
|
|
|
|
:param album_ids: Filter by album IDs
|
|
:type album_ids: List[str]
|
|
:param city: Filter by city name
|
|
:type city: str
|
|
:param country: Filter by country name
|
|
:type country: str
|
|
:param created_after: Filter by creation date (after)
|
|
:type created_after: datetime
|
|
:param created_before: Filter by creation date (before)
|
|
:type created_before: datetime
|
|
:param is_encoded: Filter by encoded status
|
|
:type is_encoded: bool
|
|
:param is_favorite: Filter by favorite status
|
|
:type is_favorite: bool
|
|
:param is_motion: Filter by motion photo status
|
|
:type is_motion: bool
|
|
:param is_not_in_album: Filter assets not in any album
|
|
:type is_not_in_album: bool
|
|
:param is_offline: Filter by offline status
|
|
:type is_offline: bool
|
|
:param lens_model: Filter by lens model
|
|
:type lens_model: str
|
|
:param library_id: Library ID to filter by
|
|
:type library_id: str
|
|
:param make: Filter by camera make
|
|
:type make: str
|
|
:param min_file_size: Minimum file size in bytes
|
|
:type min_file_size: int
|
|
:param model: Filter by camera model
|
|
:type model: str
|
|
:param ocr: Filter by OCR text content
|
|
:type ocr: str
|
|
:param person_ids: Filter by person IDs
|
|
:type person_ids: List[str]
|
|
:param rating: Filter by rating [1-5], or null for unrated
|
|
:type rating: int
|
|
:param size: Number of results to return
|
|
:type size: int
|
|
:param state: Filter by state/province name
|
|
:type state: str
|
|
:param tag_ids: Filter by tag IDs
|
|
:type tag_ids: List[str]
|
|
:param taken_after: Filter by taken date (after)
|
|
:type taken_after: datetime
|
|
:param taken_before: Filter by taken date (before)
|
|
:type taken_before: datetime
|
|
:param trashed_after: Filter by trash date (after)
|
|
:type trashed_after: datetime
|
|
:param trashed_before: Filter by trash date (before)
|
|
:type trashed_before: datetime
|
|
:param type:
|
|
:type type: AssetTypeEnum
|
|
:param updated_after: Filter by update date (after)
|
|
:type updated_after: datetime
|
|
:param updated_before: Filter by update date (before)
|
|
:type updated_before: datetime
|
|
:param visibility:
|
|
:type visibility: AssetVisibility
|
|
:param with_deleted: Include deleted assets
|
|
:type with_deleted: bool
|
|
:param with_exif: Include EXIF data in response
|
|
:type with_exif: 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._search_large_assets_serialize(
|
|
album_ids=album_ids,
|
|
city=city,
|
|
country=country,
|
|
created_after=created_after,
|
|
created_before=created_before,
|
|
is_encoded=is_encoded,
|
|
is_favorite=is_favorite,
|
|
is_motion=is_motion,
|
|
is_not_in_album=is_not_in_album,
|
|
is_offline=is_offline,
|
|
lens_model=lens_model,
|
|
library_id=library_id,
|
|
make=make,
|
|
min_file_size=min_file_size,
|
|
model=model,
|
|
ocr=ocr,
|
|
person_ids=person_ids,
|
|
rating=rating,
|
|
size=size,
|
|
state=state,
|
|
tag_ids=tag_ids,
|
|
taken_after=taken_after,
|
|
taken_before=taken_before,
|
|
trashed_after=trashed_after,
|
|
trashed_before=trashed_before,
|
|
type=type,
|
|
updated_after=updated_after,
|
|
updated_before=updated_before,
|
|
visibility=visibility,
|
|
with_deleted=with_deleted,
|
|
with_exif=with_exif,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[AssetResponseDto]",
|
|
}
|
|
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_large_assets_with_http_info(
|
|
self,
|
|
album_ids: Annotated[Optional[List[Annotated[str, Field(strict=True)]]], Field(description="Filter by album IDs")] = None,
|
|
city: Annotated[Optional[StrictStr], Field(description="Filter by city name")] = None,
|
|
country: Annotated[Optional[StrictStr], Field(description="Filter by country name")] = None,
|
|
created_after: Annotated[Optional[datetime], Field(description="Filter by creation date (after)")] = None,
|
|
created_before: Annotated[Optional[datetime], Field(description="Filter by creation date (before)")] = None,
|
|
is_encoded: Annotated[Optional[StrictBool], Field(description="Filter by encoded status")] = None,
|
|
is_favorite: Annotated[Optional[StrictBool], Field(description="Filter by favorite status")] = None,
|
|
is_motion: Annotated[Optional[StrictBool], Field(description="Filter by motion photo status")] = None,
|
|
is_not_in_album: Annotated[Optional[StrictBool], Field(description="Filter assets not in any album")] = None,
|
|
is_offline: Annotated[Optional[StrictBool], Field(description="Filter by offline status")] = None,
|
|
lens_model: Annotated[Optional[StrictStr], Field(description="Filter by lens model")] = None,
|
|
library_id: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Library ID to filter by")] = None,
|
|
make: Annotated[Optional[StrictStr], Field(description="Filter by camera make")] = None,
|
|
min_file_size: Annotated[Optional[Annotated[int, Field(le=9007199254740991, strict=True, ge=0)]], Field(description="Minimum file size in bytes")] = None,
|
|
model: Annotated[Optional[StrictStr], Field(description="Filter by camera model")] = None,
|
|
ocr: Annotated[Optional[StrictStr], Field(description="Filter by OCR text content")] = None,
|
|
person_ids: Annotated[Optional[List[Annotated[str, Field(strict=True)]]], Field(description="Filter by person IDs")] = None,
|
|
rating: Annotated[Optional[Annotated[int, Field(le=5, strict=True, ge=1)]], Field(description="Filter by rating [1-5], or null for unrated")] = None,
|
|
size: Annotated[Optional[Annotated[int, Field(le=1000, strict=True, ge=1)]], Field(description="Number of results to return")] = None,
|
|
state: Annotated[Optional[StrictStr], Field(description="Filter by state/province name")] = None,
|
|
tag_ids: Annotated[Optional[List[Annotated[str, Field(strict=True)]]], Field(description="Filter by tag IDs")] = None,
|
|
taken_after: Annotated[Optional[datetime], Field(description="Filter by taken date (after)")] = None,
|
|
taken_before: Annotated[Optional[datetime], Field(description="Filter by taken date (before)")] = None,
|
|
trashed_after: Annotated[Optional[datetime], Field(description="Filter by trash date (after)")] = None,
|
|
trashed_before: Annotated[Optional[datetime], Field(description="Filter by trash date (before)")] = None,
|
|
type: Optional[AssetTypeEnum] = None,
|
|
updated_after: Annotated[Optional[datetime], Field(description="Filter by update date (after)")] = None,
|
|
updated_before: Annotated[Optional[datetime], Field(description="Filter by update date (before)")] = None,
|
|
visibility: Optional[AssetVisibility] = None,
|
|
with_deleted: Annotated[Optional[StrictBool], Field(description="Include deleted assets")] = None,
|
|
with_exif: Annotated[Optional[StrictBool], Field(description="Include EXIF data in response")] = 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[AssetResponseDto]]:
|
|
"""Search large assets
|
|
|
|
Search for assets that are considered large based on specified criteria.
|
|
|
|
:param album_ids: Filter by album IDs
|
|
:type album_ids: List[str]
|
|
:param city: Filter by city name
|
|
:type city: str
|
|
:param country: Filter by country name
|
|
:type country: str
|
|
:param created_after: Filter by creation date (after)
|
|
:type created_after: datetime
|
|
:param created_before: Filter by creation date (before)
|
|
:type created_before: datetime
|
|
:param is_encoded: Filter by encoded status
|
|
:type is_encoded: bool
|
|
:param is_favorite: Filter by favorite status
|
|
:type is_favorite: bool
|
|
:param is_motion: Filter by motion photo status
|
|
:type is_motion: bool
|
|
:param is_not_in_album: Filter assets not in any album
|
|
:type is_not_in_album: bool
|
|
:param is_offline: Filter by offline status
|
|
:type is_offline: bool
|
|
:param lens_model: Filter by lens model
|
|
:type lens_model: str
|
|
:param library_id: Library ID to filter by
|
|
:type library_id: str
|
|
:param make: Filter by camera make
|
|
:type make: str
|
|
:param min_file_size: Minimum file size in bytes
|
|
:type min_file_size: int
|
|
:param model: Filter by camera model
|
|
:type model: str
|
|
:param ocr: Filter by OCR text content
|
|
:type ocr: str
|
|
:param person_ids: Filter by person IDs
|
|
:type person_ids: List[str]
|
|
:param rating: Filter by rating [1-5], or null for unrated
|
|
:type rating: int
|
|
:param size: Number of results to return
|
|
:type size: int
|
|
:param state: Filter by state/province name
|
|
:type state: str
|
|
:param tag_ids: Filter by tag IDs
|
|
:type tag_ids: List[str]
|
|
:param taken_after: Filter by taken date (after)
|
|
:type taken_after: datetime
|
|
:param taken_before: Filter by taken date (before)
|
|
:type taken_before: datetime
|
|
:param trashed_after: Filter by trash date (after)
|
|
:type trashed_after: datetime
|
|
:param trashed_before: Filter by trash date (before)
|
|
:type trashed_before: datetime
|
|
:param type:
|
|
:type type: AssetTypeEnum
|
|
:param updated_after: Filter by update date (after)
|
|
:type updated_after: datetime
|
|
:param updated_before: Filter by update date (before)
|
|
:type updated_before: datetime
|
|
:param visibility:
|
|
:type visibility: AssetVisibility
|
|
:param with_deleted: Include deleted assets
|
|
:type with_deleted: bool
|
|
:param with_exif: Include EXIF data in response
|
|
:type with_exif: 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._search_large_assets_serialize(
|
|
album_ids=album_ids,
|
|
city=city,
|
|
country=country,
|
|
created_after=created_after,
|
|
created_before=created_before,
|
|
is_encoded=is_encoded,
|
|
is_favorite=is_favorite,
|
|
is_motion=is_motion,
|
|
is_not_in_album=is_not_in_album,
|
|
is_offline=is_offline,
|
|
lens_model=lens_model,
|
|
library_id=library_id,
|
|
make=make,
|
|
min_file_size=min_file_size,
|
|
model=model,
|
|
ocr=ocr,
|
|
person_ids=person_ids,
|
|
rating=rating,
|
|
size=size,
|
|
state=state,
|
|
tag_ids=tag_ids,
|
|
taken_after=taken_after,
|
|
taken_before=taken_before,
|
|
trashed_after=trashed_after,
|
|
trashed_before=trashed_before,
|
|
type=type,
|
|
updated_after=updated_after,
|
|
updated_before=updated_before,
|
|
visibility=visibility,
|
|
with_deleted=with_deleted,
|
|
with_exif=with_exif,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[AssetResponseDto]",
|
|
}
|
|
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_large_assets_without_preload_content(
|
|
self,
|
|
album_ids: Annotated[Optional[List[Annotated[str, Field(strict=True)]]], Field(description="Filter by album IDs")] = None,
|
|
city: Annotated[Optional[StrictStr], Field(description="Filter by city name")] = None,
|
|
country: Annotated[Optional[StrictStr], Field(description="Filter by country name")] = None,
|
|
created_after: Annotated[Optional[datetime], Field(description="Filter by creation date (after)")] = None,
|
|
created_before: Annotated[Optional[datetime], Field(description="Filter by creation date (before)")] = None,
|
|
is_encoded: Annotated[Optional[StrictBool], Field(description="Filter by encoded status")] = None,
|
|
is_favorite: Annotated[Optional[StrictBool], Field(description="Filter by favorite status")] = None,
|
|
is_motion: Annotated[Optional[StrictBool], Field(description="Filter by motion photo status")] = None,
|
|
is_not_in_album: Annotated[Optional[StrictBool], Field(description="Filter assets not in any album")] = None,
|
|
is_offline: Annotated[Optional[StrictBool], Field(description="Filter by offline status")] = None,
|
|
lens_model: Annotated[Optional[StrictStr], Field(description="Filter by lens model")] = None,
|
|
library_id: Annotated[Optional[Annotated[str, Field(strict=True)]], Field(description="Library ID to filter by")] = None,
|
|
make: Annotated[Optional[StrictStr], Field(description="Filter by camera make")] = None,
|
|
min_file_size: Annotated[Optional[Annotated[int, Field(le=9007199254740991, strict=True, ge=0)]], Field(description="Minimum file size in bytes")] = None,
|
|
model: Annotated[Optional[StrictStr], Field(description="Filter by camera model")] = None,
|
|
ocr: Annotated[Optional[StrictStr], Field(description="Filter by OCR text content")] = None,
|
|
person_ids: Annotated[Optional[List[Annotated[str, Field(strict=True)]]], Field(description="Filter by person IDs")] = None,
|
|
rating: Annotated[Optional[Annotated[int, Field(le=5, strict=True, ge=1)]], Field(description="Filter by rating [1-5], or null for unrated")] = None,
|
|
size: Annotated[Optional[Annotated[int, Field(le=1000, strict=True, ge=1)]], Field(description="Number of results to return")] = None,
|
|
state: Annotated[Optional[StrictStr], Field(description="Filter by state/province name")] = None,
|
|
tag_ids: Annotated[Optional[List[Annotated[str, Field(strict=True)]]], Field(description="Filter by tag IDs")] = None,
|
|
taken_after: Annotated[Optional[datetime], Field(description="Filter by taken date (after)")] = None,
|
|
taken_before: Annotated[Optional[datetime], Field(description="Filter by taken date (before)")] = None,
|
|
trashed_after: Annotated[Optional[datetime], Field(description="Filter by trash date (after)")] = None,
|
|
trashed_before: Annotated[Optional[datetime], Field(description="Filter by trash date (before)")] = None,
|
|
type: Optional[AssetTypeEnum] = None,
|
|
updated_after: Annotated[Optional[datetime], Field(description="Filter by update date (after)")] = None,
|
|
updated_before: Annotated[Optional[datetime], Field(description="Filter by update date (before)")] = None,
|
|
visibility: Optional[AssetVisibility] = None,
|
|
with_deleted: Annotated[Optional[StrictBool], Field(description="Include deleted assets")] = None,
|
|
with_exif: Annotated[Optional[StrictBool], Field(description="Include EXIF data in response")] = 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 large assets
|
|
|
|
Search for assets that are considered large based on specified criteria.
|
|
|
|
:param album_ids: Filter by album IDs
|
|
:type album_ids: List[str]
|
|
:param city: Filter by city name
|
|
:type city: str
|
|
:param country: Filter by country name
|
|
:type country: str
|
|
:param created_after: Filter by creation date (after)
|
|
:type created_after: datetime
|
|
:param created_before: Filter by creation date (before)
|
|
:type created_before: datetime
|
|
:param is_encoded: Filter by encoded status
|
|
:type is_encoded: bool
|
|
:param is_favorite: Filter by favorite status
|
|
:type is_favorite: bool
|
|
:param is_motion: Filter by motion photo status
|
|
:type is_motion: bool
|
|
:param is_not_in_album: Filter assets not in any album
|
|
:type is_not_in_album: bool
|
|
:param is_offline: Filter by offline status
|
|
:type is_offline: bool
|
|
:param lens_model: Filter by lens model
|
|
:type lens_model: str
|
|
:param library_id: Library ID to filter by
|
|
:type library_id: str
|
|
:param make: Filter by camera make
|
|
:type make: str
|
|
:param min_file_size: Minimum file size in bytes
|
|
:type min_file_size: int
|
|
:param model: Filter by camera model
|
|
:type model: str
|
|
:param ocr: Filter by OCR text content
|
|
:type ocr: str
|
|
:param person_ids: Filter by person IDs
|
|
:type person_ids: List[str]
|
|
:param rating: Filter by rating [1-5], or null for unrated
|
|
:type rating: int
|
|
:param size: Number of results to return
|
|
:type size: int
|
|
:param state: Filter by state/province name
|
|
:type state: str
|
|
:param tag_ids: Filter by tag IDs
|
|
:type tag_ids: List[str]
|
|
:param taken_after: Filter by taken date (after)
|
|
:type taken_after: datetime
|
|
:param taken_before: Filter by taken date (before)
|
|
:type taken_before: datetime
|
|
:param trashed_after: Filter by trash date (after)
|
|
:type trashed_after: datetime
|
|
:param trashed_before: Filter by trash date (before)
|
|
:type trashed_before: datetime
|
|
:param type:
|
|
:type type: AssetTypeEnum
|
|
:param updated_after: Filter by update date (after)
|
|
:type updated_after: datetime
|
|
:param updated_before: Filter by update date (before)
|
|
:type updated_before: datetime
|
|
:param visibility:
|
|
:type visibility: AssetVisibility
|
|
:param with_deleted: Include deleted assets
|
|
:type with_deleted: bool
|
|
:param with_exif: Include EXIF data in response
|
|
:type with_exif: 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._search_large_assets_serialize(
|
|
album_ids=album_ids,
|
|
city=city,
|
|
country=country,
|
|
created_after=created_after,
|
|
created_before=created_before,
|
|
is_encoded=is_encoded,
|
|
is_favorite=is_favorite,
|
|
is_motion=is_motion,
|
|
is_not_in_album=is_not_in_album,
|
|
is_offline=is_offline,
|
|
lens_model=lens_model,
|
|
library_id=library_id,
|
|
make=make,
|
|
min_file_size=min_file_size,
|
|
model=model,
|
|
ocr=ocr,
|
|
person_ids=person_ids,
|
|
rating=rating,
|
|
size=size,
|
|
state=state,
|
|
tag_ids=tag_ids,
|
|
taken_after=taken_after,
|
|
taken_before=taken_before,
|
|
trashed_after=trashed_after,
|
|
trashed_before=trashed_before,
|
|
type=type,
|
|
updated_after=updated_after,
|
|
updated_before=updated_before,
|
|
visibility=visibility,
|
|
with_deleted=with_deleted,
|
|
with_exif=with_exif,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[AssetResponseDto]",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _search_large_assets_serialize(
|
|
self,
|
|
album_ids,
|
|
city,
|
|
country,
|
|
created_after,
|
|
created_before,
|
|
is_encoded,
|
|
is_favorite,
|
|
is_motion,
|
|
is_not_in_album,
|
|
is_offline,
|
|
lens_model,
|
|
library_id,
|
|
make,
|
|
min_file_size,
|
|
model,
|
|
ocr,
|
|
person_ids,
|
|
rating,
|
|
size,
|
|
state,
|
|
tag_ids,
|
|
taken_after,
|
|
taken_before,
|
|
trashed_after,
|
|
trashed_before,
|
|
type,
|
|
updated_after,
|
|
updated_before,
|
|
visibility,
|
|
with_deleted,
|
|
with_exif,
|
|
_request_auth,
|
|
_content_type,
|
|
_headers,
|
|
_host_index,
|
|
) -> RequestSerialized:
|
|
|
|
_host = None
|
|
|
|
_collection_formats: Dict[str, str] = {
|
|
'albumIds': 'multi',
|
|
'personIds': 'multi',
|
|
'tagIds': '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, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
|
|
] = {}
|
|
_body_params: Optional[bytes] = None
|
|
|
|
# process the path parameters
|
|
# process the query parameters
|
|
if album_ids is not None:
|
|
|
|
_query_params.append(('albumIds', album_ids))
|
|
|
|
if city is not None:
|
|
|
|
_query_params.append(('city', city))
|
|
|
|
if country is not None:
|
|
|
|
_query_params.append(('country', country))
|
|
|
|
if created_after is not None:
|
|
if isinstance(created_after, datetime):
|
|
_query_params.append(
|
|
(
|
|
'createdAfter',
|
|
created_after.strftime(
|
|
self.api_client.configuration.datetime_format
|
|
)
|
|
)
|
|
)
|
|
else:
|
|
_query_params.append(('createdAfter', created_after))
|
|
|
|
if created_before is not None:
|
|
if isinstance(created_before, datetime):
|
|
_query_params.append(
|
|
(
|
|
'createdBefore',
|
|
created_before.strftime(
|
|
self.api_client.configuration.datetime_format
|
|
)
|
|
)
|
|
)
|
|
else:
|
|
_query_params.append(('createdBefore', created_before))
|
|
|
|
if is_encoded is not None:
|
|
|
|
_query_params.append(('isEncoded', is_encoded))
|
|
|
|
if is_favorite is not None:
|
|
|
|
_query_params.append(('isFavorite', is_favorite))
|
|
|
|
if is_motion is not None:
|
|
|
|
_query_params.append(('isMotion', is_motion))
|
|
|
|
if is_not_in_album is not None:
|
|
|
|
_query_params.append(('isNotInAlbum', is_not_in_album))
|
|
|
|
if is_offline is not None:
|
|
|
|
_query_params.append(('isOffline', is_offline))
|
|
|
|
if lens_model is not None:
|
|
|
|
_query_params.append(('lensModel', lens_model))
|
|
|
|
if library_id is not None:
|
|
|
|
_query_params.append(('libraryId', library_id))
|
|
|
|
if make is not None:
|
|
|
|
_query_params.append(('make', make))
|
|
|
|
if min_file_size is not None:
|
|
|
|
_query_params.append(('minFileSize', min_file_size))
|
|
|
|
if model is not None:
|
|
|
|
_query_params.append(('model', model))
|
|
|
|
if ocr is not None:
|
|
|
|
_query_params.append(('ocr', ocr))
|
|
|
|
if person_ids is not None:
|
|
|
|
_query_params.append(('personIds', person_ids))
|
|
|
|
if rating is not None:
|
|
|
|
_query_params.append(('rating', rating))
|
|
|
|
if size is not None:
|
|
|
|
_query_params.append(('size', size))
|
|
|
|
if state is not None:
|
|
|
|
_query_params.append(('state', state))
|
|
|
|
if tag_ids is not None:
|
|
|
|
_query_params.append(('tagIds', tag_ids))
|
|
|
|
if taken_after is not None:
|
|
if isinstance(taken_after, datetime):
|
|
_query_params.append(
|
|
(
|
|
'takenAfter',
|
|
taken_after.strftime(
|
|
self.api_client.configuration.datetime_format
|
|
)
|
|
)
|
|
)
|
|
else:
|
|
_query_params.append(('takenAfter', taken_after))
|
|
|
|
if taken_before is not None:
|
|
if isinstance(taken_before, datetime):
|
|
_query_params.append(
|
|
(
|
|
'takenBefore',
|
|
taken_before.strftime(
|
|
self.api_client.configuration.datetime_format
|
|
)
|
|
)
|
|
)
|
|
else:
|
|
_query_params.append(('takenBefore', taken_before))
|
|
|
|
if trashed_after is not None:
|
|
if isinstance(trashed_after, datetime):
|
|
_query_params.append(
|
|
(
|
|
'trashedAfter',
|
|
trashed_after.strftime(
|
|
self.api_client.configuration.datetime_format
|
|
)
|
|
)
|
|
)
|
|
else:
|
|
_query_params.append(('trashedAfter', trashed_after))
|
|
|
|
if trashed_before is not None:
|
|
if isinstance(trashed_before, datetime):
|
|
_query_params.append(
|
|
(
|
|
'trashedBefore',
|
|
trashed_before.strftime(
|
|
self.api_client.configuration.datetime_format
|
|
)
|
|
)
|
|
)
|
|
else:
|
|
_query_params.append(('trashedBefore', trashed_before))
|
|
|
|
if type is not None:
|
|
|
|
_query_params.append(('type', type.value))
|
|
|
|
if updated_after is not None:
|
|
if isinstance(updated_after, datetime):
|
|
_query_params.append(
|
|
(
|
|
'updatedAfter',
|
|
updated_after.strftime(
|
|
self.api_client.configuration.datetime_format
|
|
)
|
|
)
|
|
)
|
|
else:
|
|
_query_params.append(('updatedAfter', updated_after))
|
|
|
|
if updated_before is not None:
|
|
if isinstance(updated_before, datetime):
|
|
_query_params.append(
|
|
(
|
|
'updatedBefore',
|
|
updated_before.strftime(
|
|
self.api_client.configuration.datetime_format
|
|
)
|
|
)
|
|
)
|
|
else:
|
|
_query_params.append(('updatedBefore', updated_before))
|
|
|
|
if visibility is not None:
|
|
|
|
_query_params.append(('visibility', visibility.value))
|
|
|
|
if with_deleted is not None:
|
|
|
|
_query_params.append(('withDeleted', with_deleted))
|
|
|
|
if with_exif is not None:
|
|
|
|
_query_params.append(('withExif', with_exif))
|
|
|
|
# process the header parameters
|
|
# process the form parameters
|
|
# process the body parameter
|
|
|
|
|
|
# set the HTTP header `Accept`
|
|
if 'Accept' not in _header_params:
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
'cookie',
|
|
'api_key',
|
|
'bearer'
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='POST',
|
|
resource_path='/search/large-assets',
|
|
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_person(
|
|
self,
|
|
name: Annotated[StrictStr, Field(description="Person name to search for")],
|
|
with_hidden: Annotated[Optional[StrictBool], Field(description="Include hidden people")] = 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[PersonResponseDto]:
|
|
"""Search people
|
|
|
|
Search for people by name.
|
|
|
|
:param name: Person name to search for (required)
|
|
:type name: str
|
|
:param with_hidden: Include hidden people
|
|
:type with_hidden: 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._search_person_serialize(
|
|
name=name,
|
|
with_hidden=with_hidden,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[PersonResponseDto]",
|
|
}
|
|
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_person_with_http_info(
|
|
self,
|
|
name: Annotated[StrictStr, Field(description="Person name to search for")],
|
|
with_hidden: Annotated[Optional[StrictBool], Field(description="Include hidden people")] = 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[PersonResponseDto]]:
|
|
"""Search people
|
|
|
|
Search for people by name.
|
|
|
|
:param name: Person name to search for (required)
|
|
:type name: str
|
|
:param with_hidden: Include hidden people
|
|
:type with_hidden: 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._search_person_serialize(
|
|
name=name,
|
|
with_hidden=with_hidden,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[PersonResponseDto]",
|
|
}
|
|
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_person_without_preload_content(
|
|
self,
|
|
name: Annotated[StrictStr, Field(description="Person name to search for")],
|
|
with_hidden: Annotated[Optional[StrictBool], Field(description="Include hidden people")] = 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 people
|
|
|
|
Search for people by name.
|
|
|
|
:param name: Person name to search for (required)
|
|
:type name: str
|
|
:param with_hidden: Include hidden people
|
|
:type with_hidden: 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._search_person_serialize(
|
|
name=name,
|
|
with_hidden=with_hidden,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[PersonResponseDto]",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _search_person_serialize(
|
|
self,
|
|
name,
|
|
with_hidden,
|
|
_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, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
|
|
] = {}
|
|
_body_params: Optional[bytes] = None
|
|
|
|
# process the path parameters
|
|
# process the query parameters
|
|
if name is not None:
|
|
|
|
_query_params.append(('name', name))
|
|
|
|
if with_hidden is not None:
|
|
|
|
_query_params.append(('withHidden', with_hidden))
|
|
|
|
# process the header parameters
|
|
# process the form parameters
|
|
# process the body parameter
|
|
|
|
|
|
# set the HTTP header `Accept`
|
|
if 'Accept' not in _header_params:
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
'cookie',
|
|
'api_key',
|
|
'bearer'
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='GET',
|
|
resource_path='/search/person',
|
|
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_places(
|
|
self,
|
|
name: Annotated[StrictStr, Field(description="Place name to search for")],
|
|
_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[PlacesResponseDto]:
|
|
"""Search places
|
|
|
|
Search for places by name.
|
|
|
|
:param name: Place name to search for (required)
|
|
:type 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._search_places_serialize(
|
|
name=name,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[PlacesResponseDto]",
|
|
}
|
|
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_places_with_http_info(
|
|
self,
|
|
name: Annotated[StrictStr, Field(description="Place name to search for")],
|
|
_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[PlacesResponseDto]]:
|
|
"""Search places
|
|
|
|
Search for places by name.
|
|
|
|
:param name: Place name to search for (required)
|
|
:type 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._search_places_serialize(
|
|
name=name,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[PlacesResponseDto]",
|
|
}
|
|
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_places_without_preload_content(
|
|
self,
|
|
name: Annotated[StrictStr, Field(description="Place name to search for")],
|
|
_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 places
|
|
|
|
Search for places by name.
|
|
|
|
:param name: Place name to search for (required)
|
|
:type 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._search_places_serialize(
|
|
name=name,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[PlacesResponseDto]",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _search_places_serialize(
|
|
self,
|
|
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, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
|
|
] = {}
|
|
_body_params: Optional[bytes] = None
|
|
|
|
# process the path parameters
|
|
# process the query parameters
|
|
if name is not None:
|
|
|
|
_query_params.append(('name', name))
|
|
|
|
# process the header parameters
|
|
# process the form parameters
|
|
# process the body parameter
|
|
|
|
|
|
# set the HTTP header `Accept`
|
|
if 'Accept' not in _header_params:
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
'cookie',
|
|
'api_key',
|
|
'bearer'
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='GET',
|
|
resource_path='/search/places',
|
|
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_random(
|
|
self,
|
|
random_search_dto: RandomSearchDto,
|
|
_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[AssetResponseDto]:
|
|
"""Search random assets
|
|
|
|
Retrieve a random selection of assets based on the provided criteria.
|
|
|
|
:param random_search_dto: (required)
|
|
:type random_search_dto: RandomSearchDto
|
|
: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_random_serialize(
|
|
random_search_dto=random_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[AssetResponseDto]",
|
|
}
|
|
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_random_with_http_info(
|
|
self,
|
|
random_search_dto: RandomSearchDto,
|
|
_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[AssetResponseDto]]:
|
|
"""Search random assets
|
|
|
|
Retrieve a random selection of assets based on the provided criteria.
|
|
|
|
:param random_search_dto: (required)
|
|
:type random_search_dto: RandomSearchDto
|
|
: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_random_serialize(
|
|
random_search_dto=random_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[AssetResponseDto]",
|
|
}
|
|
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_random_without_preload_content(
|
|
self,
|
|
random_search_dto: RandomSearchDto,
|
|
_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 random assets
|
|
|
|
Retrieve a random selection of assets based on the provided criteria.
|
|
|
|
:param random_search_dto: (required)
|
|
:type random_search_dto: RandomSearchDto
|
|
: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_random_serialize(
|
|
random_search_dto=random_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "List[AssetResponseDto]",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _search_random_serialize(
|
|
self,
|
|
random_search_dto,
|
|
_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, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
|
|
] = {}
|
|
_body_params: Optional[bytes] = None
|
|
|
|
# process the path parameters
|
|
# process the query parameters
|
|
# process the header parameters
|
|
# process the form parameters
|
|
# process the body parameter
|
|
if random_search_dto is not None:
|
|
_body_params = random_search_dto
|
|
|
|
|
|
# set the HTTP header `Accept`
|
|
if 'Accept' not in _header_params:
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
# set the HTTP header `Content-Type`
|
|
if _content_type:
|
|
_header_params['Content-Type'] = _content_type
|
|
else:
|
|
_default_content_type = (
|
|
self.api_client.select_header_content_type(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
)
|
|
if _default_content_type is not None:
|
|
_header_params['Content-Type'] = _default_content_type
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
'cookie',
|
|
'api_key',
|
|
'bearer'
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='POST',
|
|
resource_path='/search/random',
|
|
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_smart(
|
|
self,
|
|
smart_search_dto: SmartSearchDto,
|
|
_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,
|
|
) -> SearchResponseDto:
|
|
"""Smart asset search
|
|
|
|
Perform a smart search for assets by using machine learning vectors to determine relevance.
|
|
|
|
:param smart_search_dto: (required)
|
|
:type smart_search_dto: SmartSearchDto
|
|
: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_smart_serialize(
|
|
smart_search_dto=smart_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "SearchResponseDto",
|
|
}
|
|
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_smart_with_http_info(
|
|
self,
|
|
smart_search_dto: SmartSearchDto,
|
|
_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[SearchResponseDto]:
|
|
"""Smart asset search
|
|
|
|
Perform a smart search for assets by using machine learning vectors to determine relevance.
|
|
|
|
:param smart_search_dto: (required)
|
|
:type smart_search_dto: SmartSearchDto
|
|
: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_smart_serialize(
|
|
smart_search_dto=smart_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "SearchResponseDto",
|
|
}
|
|
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_smart_without_preload_content(
|
|
self,
|
|
smart_search_dto: SmartSearchDto,
|
|
_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:
|
|
"""Smart asset search
|
|
|
|
Perform a smart search for assets by using machine learning vectors to determine relevance.
|
|
|
|
:param smart_search_dto: (required)
|
|
:type smart_search_dto: SmartSearchDto
|
|
: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_smart_serialize(
|
|
smart_search_dto=smart_search_dto,
|
|
_request_auth=_request_auth,
|
|
_content_type=_content_type,
|
|
_headers=_headers,
|
|
_host_index=_host_index
|
|
)
|
|
|
|
_response_types_map: Dict[str, Optional[str]] = {
|
|
'200': "SearchResponseDto",
|
|
}
|
|
response_data = self.api_client.call_api(
|
|
*_param,
|
|
_request_timeout=_request_timeout
|
|
)
|
|
return response_data.response
|
|
|
|
|
|
def _search_smart_serialize(
|
|
self,
|
|
smart_search_dto,
|
|
_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, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
|
|
] = {}
|
|
_body_params: Optional[bytes] = None
|
|
|
|
# process the path parameters
|
|
# process the query parameters
|
|
# process the header parameters
|
|
# process the form parameters
|
|
# process the body parameter
|
|
if smart_search_dto is not None:
|
|
_body_params = smart_search_dto
|
|
|
|
|
|
# set the HTTP header `Accept`
|
|
if 'Accept' not in _header_params:
|
|
_header_params['Accept'] = self.api_client.select_header_accept(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
|
|
# set the HTTP header `Content-Type`
|
|
if _content_type:
|
|
_header_params['Content-Type'] = _content_type
|
|
else:
|
|
_default_content_type = (
|
|
self.api_client.select_header_content_type(
|
|
[
|
|
'application/json'
|
|
]
|
|
)
|
|
)
|
|
if _default_content_type is not None:
|
|
_header_params['Content-Type'] = _default_content_type
|
|
|
|
# authentication setting
|
|
_auth_settings: List[str] = [
|
|
'cookie',
|
|
'api_key',
|
|
'bearer'
|
|
]
|
|
|
|
return self.api_client.param_serialize(
|
|
method='POST',
|
|
resource_path='/search/smart',
|
|
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
|
|
)
|
|
|
|
|