green-20180509/alibabacloud_green20180509/models.py (5,017 lines of code) (raw):
# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
from Tea.model import TeaModel
from typing import Dict
class AddFacesRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class AddFacesResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddFacesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: AddFacesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = AddFacesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddGroupsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class AddGroupsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddGroupsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: AddGroupsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = AddGroupsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddPersonRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class AddPersonResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddPersonResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: AddPersonResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = AddPersonResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddSimilarityImageRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class AddSimilarityImageResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddSimilarityImageResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: AddSimilarityImageResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = AddSimilarityImageResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddSimilarityLibraryRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class AddSimilarityLibraryResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddSimilarityLibraryResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: AddSimilarityLibraryResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = AddSimilarityLibraryResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddVideoDnaRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class AddVideoDnaResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddVideoDnaResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: AddVideoDnaResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = AddVideoDnaResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class AddVideoDnaGroupRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class AddVideoDnaGroupResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class AddVideoDnaGroupResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: AddVideoDnaGroupResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = AddVideoDnaGroupResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteFacesRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DeleteFacesResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteFacesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteFacesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteFacesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteGroupsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DeleteGroupsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteGroupsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteGroupsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteGroupsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeletePersonRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class DeletePersonResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeletePersonResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeletePersonResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeletePersonResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteSimilarityImageRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class DeleteSimilarityImageResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteSimilarityImageResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteSimilarityImageResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteSimilarityImageResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteSimilarityLibraryRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class DeleteSimilarityLibraryResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteSimilarityLibraryResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteSimilarityLibraryResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteSimilarityLibraryResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteVideoDnaRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class DeleteVideoDnaResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteVideoDnaResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteVideoDnaResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteVideoDnaResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DeleteVideoDnaGroupRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class DeleteVideoDnaGroupResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DeleteVideoDnaGroupResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DeleteVideoDnaGroupResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DeleteVideoDnaGroupResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class DetectFaceRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class DetectFaceResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['requestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('requestId') is not None:
self.request_id = m.get('requestId')
return self
class DetectFaceResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: DetectFaceResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = DetectFaceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class FileAsyncScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class FileAsyncScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class FileAsyncScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: FileAsyncScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = FileAsyncScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class FileAsyncScanResultsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class FileAsyncScanResultsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class FileAsyncScanResultsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: FileAsyncScanResultsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = FileAsyncScanResultsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class FileAsyncScanV2ResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['requestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('requestId') is not None:
self.request_id = m.get('requestId')
return self
class FileAsyncScanV2Response(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: FileAsyncScanV2ResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = FileAsyncScanV2ResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetFacesRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class GetFacesResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetFacesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetFacesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetFacesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetGroupsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class GetGroupsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetGroupsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetGroupsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetGroupsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetPersonRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class GetPersonResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetPersonResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetPersonResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetPersonResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetPersonsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class GetPersonsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetPersonsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetPersonsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetPersonsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetSimilarityImageRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class GetSimilarityImageResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetSimilarityImageResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetSimilarityImageResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetSimilarityImageResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetSimilarityLibraryRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class GetSimilarityLibraryResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetSimilarityLibraryResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: GetSimilarityLibraryResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = GetSimilarityLibraryResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ImageAsyncManualScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class ImageAsyncManualScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ImageAsyncManualScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ImageAsyncManualScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ImageAsyncManualScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ImageAsyncManualScanResultsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class ImageAsyncManualScanResultsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ImageAsyncManualScanResultsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ImageAsyncManualScanResultsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ImageAsyncManualScanResultsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ImageAsyncScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class ImageAsyncScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ImageAsyncScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ImageAsyncScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ImageAsyncScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ImageAsyncScanResultsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class ImageAsyncScanResultsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ImageAsyncScanResultsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ImageAsyncScanResultsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ImageAsyncScanResultsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ImageScanFeedbackRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class ImageScanFeedbackResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ImageScanFeedbackResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ImageScanFeedbackResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ImageScanFeedbackResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ImageSyncScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class ImageSyncScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ImageSyncScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ImageSyncScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ImageSyncScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListSimilarityImagesRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class ListSimilarityImagesResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListSimilarityImagesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListSimilarityImagesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListSimilarityImagesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class ListSimilarityLibrariesRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class ListSimilarityLibrariesResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class ListSimilarityLibrariesResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: ListSimilarityLibrariesResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = ListSimilarityLibrariesResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class LiveStreamAsyncScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class LiveStreamAsyncScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class LiveStreamAsyncScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: LiveStreamAsyncScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = LiveStreamAsyncScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class LiveStreamAsyncScanResultsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class LiveStreamAsyncScanResultsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class LiveStreamAsyncScanResultsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: LiveStreamAsyncScanResultsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = LiveStreamAsyncScanResultsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class LiveStreamCancelScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class LiveStreamCancelScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class LiveStreamCancelScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: LiveStreamCancelScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = LiveStreamCancelScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class SetPersonRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class SetPersonResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class SetPersonResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: SetPersonResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = SetPersonResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class TextAsyncManualScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class TextAsyncManualScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class TextAsyncManualScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: TextAsyncManualScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = TextAsyncManualScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class TextAsyncManualScanResultsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class TextAsyncManualScanResultsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class TextAsyncManualScanResultsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: TextAsyncManualScanResultsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = TextAsyncManualScanResultsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class TextFeedbackRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class TextFeedbackResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class TextFeedbackResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: TextFeedbackResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = TextFeedbackResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class TextScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class TextScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class TextScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: TextScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = TextScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class UploadCredentialsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class UploadCredentialsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class UploadCredentialsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: UploadCredentialsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = UploadCredentialsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VideoAsyncManualScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VideoAsyncManualScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VideoAsyncManualScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VideoAsyncManualScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VideoAsyncManualScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VideoAsyncManualScanResultsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VideoAsyncManualScanResultsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VideoAsyncManualScanResultsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VideoAsyncManualScanResultsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VideoAsyncManualScanResultsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VideoAsyncScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VideoAsyncScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VideoAsyncScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VideoAsyncScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VideoAsyncScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VideoAsyncScanResultsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VideoAsyncScanResultsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VideoAsyncScanResultsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VideoAsyncScanResultsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VideoAsyncScanResultsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VideoCancelScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VideoCancelScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VideoCancelScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VideoCancelScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VideoCancelScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VideoFeedbackRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VideoFeedbackResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VideoFeedbackResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VideoFeedbackResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VideoFeedbackResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VideoSyncScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VideoSyncScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VideoSyncScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VideoSyncScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VideoSyncScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VodAsyncScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VodAsyncScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VodAsyncScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VodAsyncScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VodAsyncScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VodAsyncScanResultsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VodAsyncScanResultsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VodAsyncScanResultsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VodAsyncScanResultsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VodAsyncScanResultsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VoiceAsyncManualScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VoiceAsyncManualScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VoiceAsyncManualScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VoiceAsyncManualScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VoiceAsyncManualScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VoiceAsyncManualScanResultsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VoiceAsyncManualScanResultsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VoiceAsyncManualScanResultsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VoiceAsyncManualScanResultsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VoiceAsyncManualScanResultsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VoiceAsyncScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VoiceAsyncScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VoiceAsyncScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VoiceAsyncScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VoiceAsyncScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VoiceAsyncScanResultsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VoiceAsyncScanResultsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VoiceAsyncScanResultsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VoiceAsyncScanResultsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VoiceAsyncScanResultsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VoiceCancelScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class VoiceCancelScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VoiceCancelScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VoiceCancelScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VoiceCancelScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VoiceIdentityCheckRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class VoiceIdentityCheckResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VoiceIdentityCheckResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VoiceIdentityCheckResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VoiceIdentityCheckResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VoiceIdentityRegisterRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class VoiceIdentityRegisterResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VoiceIdentityRegisterResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VoiceIdentityRegisterResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VoiceIdentityRegisterResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VoiceIdentityStartCheckRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class VoiceIdentityStartCheckResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VoiceIdentityStartCheckResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VoiceIdentityStartCheckResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VoiceIdentityStartCheckResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VoiceIdentityStartRegisterRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class VoiceIdentityStartRegisterResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VoiceIdentityStartRegisterResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VoiceIdentityStartRegisterResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VoiceIdentityStartRegisterResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VoiceIdentityUnregisterRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class VoiceIdentityUnregisterResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VoiceIdentityUnregisterResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VoiceIdentityUnregisterResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VoiceIdentityUnregisterResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class VoiceSyncScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
region_id: str = None,
):
self.client_info = client_info
# This parameter is required.
self.region_id = region_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
if self.region_id is not None:
result['RegionId'] = self.region_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
if m.get('RegionId') is not None:
self.region_id = m.get('RegionId')
return self
class VoiceSyncScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class VoiceSyncScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: VoiceSyncScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = VoiceSyncScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class WebpageAsyncScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class WebpageAsyncScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class WebpageAsyncScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: WebpageAsyncScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = WebpageAsyncScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class WebpageAsyncScanResultsRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class WebpageAsyncScanResultsResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class WebpageAsyncScanResultsResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: WebpageAsyncScanResultsResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = WebpageAsyncScanResultsResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class WebpageSyncScanRequest(TeaModel):
def __init__(
self,
client_info: str = None,
):
self.client_info = client_info
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.client_info is not None:
result['ClientInfo'] = self.client_info
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('ClientInfo') is not None:
self.client_info = m.get('ClientInfo')
return self
class WebpageSyncScanResponseBody(TeaModel):
def __init__(
self,
request_id: str = None,
):
self.request_id = request_id
def validate(self):
pass
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class WebpageSyncScanResponse(TeaModel):
def __init__(
self,
headers: Dict[str, str] = None,
status_code: int = None,
body: WebpageSyncScanResponseBody = None,
):
self.headers = headers
self.status_code = status_code
self.body = body
def validate(self):
if self.body:
self.body.validate()
def to_map(self):
_map = super().to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.status_code is not None:
result['statusCode'] = self.status_code
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m: dict = None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('statusCode') is not None:
self.status_code = m.get('statusCode')
if m.get('body') is not None:
temp_model = WebpageSyncScanResponseBody()
self.body = temp_model.from_map(m['body'])
return self