ocr-20191230/alibabacloud_ocr20191230/models.py (6,065 lines of code) (raw):
# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
from Tea.model import TeaModel
class DetectCardScreenshotRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(DetectCardScreenshotRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class DetectCardScreenshotAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(DetectCardScreenshotAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class DetectCardScreenshotResponseBodyDataSpoofResultResultMap(TeaModel):
def __init__(self, screen_score=None, screen_threshold=None):
self.screen_score = screen_score # type: float
self.screen_threshold = screen_threshold # type: float
def validate(self):
pass
def to_map(self):
_map = super(DetectCardScreenshotResponseBodyDataSpoofResultResultMap, self).to_map()
if _map is not None:
return _map
result = dict()
if self.screen_score is not None:
result['ScreenScore'] = self.screen_score
if self.screen_threshold is not None:
result['ScreenThreshold'] = self.screen_threshold
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ScreenScore') is not None:
self.screen_score = m.get('ScreenScore')
if m.get('ScreenThreshold') is not None:
self.screen_threshold = m.get('ScreenThreshold')
return self
class DetectCardScreenshotResponseBodyDataSpoofResult(TeaModel):
def __init__(self, is_spoof=None, result_map=None):
self.is_spoof = is_spoof # type: bool
self.result_map = result_map # type: DetectCardScreenshotResponseBodyDataSpoofResultResultMap
def validate(self):
if self.result_map:
self.result_map.validate()
def to_map(self):
_map = super(DetectCardScreenshotResponseBodyDataSpoofResult, self).to_map()
if _map is not None:
return _map
result = dict()
if self.is_spoof is not None:
result['IsSpoof'] = self.is_spoof
if self.result_map is not None:
result['ResultMap'] = self.result_map.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('IsSpoof') is not None:
self.is_spoof = m.get('IsSpoof')
if m.get('ResultMap') is not None:
temp_model = DetectCardScreenshotResponseBodyDataSpoofResultResultMap()
self.result_map = temp_model.from_map(m['ResultMap'])
return self
class DetectCardScreenshotResponseBodyData(TeaModel):
def __init__(self, is_blur=None, is_card=None, spoof_result=None):
self.is_blur = is_blur # type: bool
self.is_card = is_card # type: bool
self.spoof_result = spoof_result # type: DetectCardScreenshotResponseBodyDataSpoofResult
def validate(self):
if self.spoof_result:
self.spoof_result.validate()
def to_map(self):
_map = super(DetectCardScreenshotResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.is_blur is not None:
result['IsBlur'] = self.is_blur
if self.is_card is not None:
result['IsCard'] = self.is_card
if self.spoof_result is not None:
result['SpoofResult'] = self.spoof_result.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('IsBlur') is not None:
self.is_blur = m.get('IsBlur')
if m.get('IsCard') is not None:
self.is_card = m.get('IsCard')
if m.get('SpoofResult') is not None:
temp_model = DetectCardScreenshotResponseBodyDataSpoofResult()
self.spoof_result = temp_model.from_map(m['SpoofResult'])
return self
class DetectCardScreenshotResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: DetectCardScreenshotResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(DetectCardScreenshotResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = DetectCardScreenshotResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class DetectCardScreenshotResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: DetectCardScreenshotResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(DetectCardScreenshotResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = DetectCardScreenshotResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class GetAsyncJobResultRequest(TeaModel):
def __init__(self, job_id=None):
self.job_id = job_id # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetAsyncJobResultRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.job_id is not None:
result['JobId'] = self.job_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('JobId') is not None:
self.job_id = m.get('JobId')
return self
class GetAsyncJobResultResponseBodyData(TeaModel):
def __init__(self, error_code=None, error_message=None, job_id=None, result=None, status=None):
self.error_code = error_code # type: str
self.error_message = error_message # type: str
self.job_id = job_id # type: str
self.result = result # type: str
self.status = status # type: str
def validate(self):
pass
def to_map(self):
_map = super(GetAsyncJobResultResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.error_code is not None:
result['ErrorCode'] = self.error_code
if self.error_message is not None:
result['ErrorMessage'] = self.error_message
if self.job_id is not None:
result['JobId'] = self.job_id
if self.result is not None:
result['Result'] = self.result
if self.status is not None:
result['Status'] = self.status
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ErrorCode') is not None:
self.error_code = m.get('ErrorCode')
if m.get('ErrorMessage') is not None:
self.error_message = m.get('ErrorMessage')
if m.get('JobId') is not None:
self.job_id = m.get('JobId')
if m.get('Result') is not None:
self.result = m.get('Result')
if m.get('Status') is not None:
self.status = m.get('Status')
return self
class GetAsyncJobResultResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: GetAsyncJobResultResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(GetAsyncJobResultResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = GetAsyncJobResultResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class GetAsyncJobResultResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: GetAsyncJobResultResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(GetAsyncJobResultResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = GetAsyncJobResultResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeAccountPageRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeAccountPageRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeAccountPageAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeAccountPageAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeAccountPageResponseBodyDataInvalidStampAreas(TeaModel):
def __init__(self, height=None, left=None, top=None, width=None):
self.height = height # type: int
self.left = left # type: int
self.top = top # type: int
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeAccountPageResponseBodyDataInvalidStampAreas, self).to_map()
if _map is not None:
return _map
result = dict()
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeAccountPageResponseBodyDataOtherStampAreas(TeaModel):
def __init__(self, height=None, left=None, top=None, width=None):
self.height = height # type: int
self.left = left # type: int
self.top = top # type: int
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeAccountPageResponseBodyDataOtherStampAreas, self).to_map()
if _map is not None:
return _map
result = dict()
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeAccountPageResponseBodyDataRegisterStampAreas(TeaModel):
def __init__(self, height=None, left=None, top=None, width=None):
self.height = height # type: int
self.left = left # type: int
self.top = top # type: int
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeAccountPageResponseBodyDataRegisterStampAreas, self).to_map()
if _map is not None:
return _map
result = dict()
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeAccountPageResponseBodyDataTitleArea(TeaModel):
def __init__(self, height=None, left=None, top=None, width=None):
self.height = height # type: int
self.left = left # type: int
self.top = top # type: int
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeAccountPageResponseBodyDataTitleArea, self).to_map()
if _map is not None:
return _map
result = dict()
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeAccountPageResponseBodyDataUndertakeStampAreas(TeaModel):
def __init__(self, height=None, left=None, top=None, width=None):
self.height = height # type: int
self.left = left # type: int
self.top = top # type: int
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeAccountPageResponseBodyDataUndertakeStampAreas, self).to_map()
if _map is not None:
return _map
result = dict()
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeAccountPageResponseBodyData(TeaModel):
def __init__(self, angle=None, birth_date=None, birth_place=None, gender=None, idnumber=None,
invalid_stamp_areas=None, name=None, nationality=None, native_place=None, other_stamp_areas=None,
register_stamp_areas=None, relation=None, title_area=None, undertake_stamp_areas=None):
self.angle = angle # type: float
self.birth_date = birth_date # type: str
self.birth_place = birth_place # type: str
self.gender = gender # type: str
self.idnumber = idnumber # type: str
self.invalid_stamp_areas = invalid_stamp_areas # type: list[RecognizeAccountPageResponseBodyDataInvalidStampAreas]
self.name = name # type: str
self.nationality = nationality # type: str
self.native_place = native_place # type: str
self.other_stamp_areas = other_stamp_areas # type: list[RecognizeAccountPageResponseBodyDataOtherStampAreas]
self.register_stamp_areas = register_stamp_areas # type: list[RecognizeAccountPageResponseBodyDataRegisterStampAreas]
self.relation = relation # type: str
self.title_area = title_area # type: RecognizeAccountPageResponseBodyDataTitleArea
self.undertake_stamp_areas = undertake_stamp_areas # type: list[RecognizeAccountPageResponseBodyDataUndertakeStampAreas]
def validate(self):
if self.invalid_stamp_areas:
for k in self.invalid_stamp_areas:
if k:
k.validate()
if self.other_stamp_areas:
for k in self.other_stamp_areas:
if k:
k.validate()
if self.register_stamp_areas:
for k in self.register_stamp_areas:
if k:
k.validate()
if self.title_area:
self.title_area.validate()
if self.undertake_stamp_areas:
for k in self.undertake_stamp_areas:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeAccountPageResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.angle is not None:
result['Angle'] = self.angle
if self.birth_date is not None:
result['BirthDate'] = self.birth_date
if self.birth_place is not None:
result['BirthPlace'] = self.birth_place
if self.gender is not None:
result['Gender'] = self.gender
if self.idnumber is not None:
result['IDNumber'] = self.idnumber
result['InvalidStampAreas'] = []
if self.invalid_stamp_areas is not None:
for k in self.invalid_stamp_areas:
result['InvalidStampAreas'].append(k.to_map() if k else None)
if self.name is not None:
result['Name'] = self.name
if self.nationality is not None:
result['Nationality'] = self.nationality
if self.native_place is not None:
result['NativePlace'] = self.native_place
result['OtherStampAreas'] = []
if self.other_stamp_areas is not None:
for k in self.other_stamp_areas:
result['OtherStampAreas'].append(k.to_map() if k else None)
result['RegisterStampAreas'] = []
if self.register_stamp_areas is not None:
for k in self.register_stamp_areas:
result['RegisterStampAreas'].append(k.to_map() if k else None)
if self.relation is not None:
result['Relation'] = self.relation
if self.title_area is not None:
result['TitleArea'] = self.title_area.to_map()
result['UndertakeStampAreas'] = []
if self.undertake_stamp_areas is not None:
for k in self.undertake_stamp_areas:
result['UndertakeStampAreas'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Angle') is not None:
self.angle = m.get('Angle')
if m.get('BirthDate') is not None:
self.birth_date = m.get('BirthDate')
if m.get('BirthPlace') is not None:
self.birth_place = m.get('BirthPlace')
if m.get('Gender') is not None:
self.gender = m.get('Gender')
if m.get('IDNumber') is not None:
self.idnumber = m.get('IDNumber')
self.invalid_stamp_areas = []
if m.get('InvalidStampAreas') is not None:
for k in m.get('InvalidStampAreas'):
temp_model = RecognizeAccountPageResponseBodyDataInvalidStampAreas()
self.invalid_stamp_areas.append(temp_model.from_map(k))
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Nationality') is not None:
self.nationality = m.get('Nationality')
if m.get('NativePlace') is not None:
self.native_place = m.get('NativePlace')
self.other_stamp_areas = []
if m.get('OtherStampAreas') is not None:
for k in m.get('OtherStampAreas'):
temp_model = RecognizeAccountPageResponseBodyDataOtherStampAreas()
self.other_stamp_areas.append(temp_model.from_map(k))
self.register_stamp_areas = []
if m.get('RegisterStampAreas') is not None:
for k in m.get('RegisterStampAreas'):
temp_model = RecognizeAccountPageResponseBodyDataRegisterStampAreas()
self.register_stamp_areas.append(temp_model.from_map(k))
if m.get('Relation') is not None:
self.relation = m.get('Relation')
if m.get('TitleArea') is not None:
temp_model = RecognizeAccountPageResponseBodyDataTitleArea()
self.title_area = temp_model.from_map(m['TitleArea'])
self.undertake_stamp_areas = []
if m.get('UndertakeStampAreas') is not None:
for k in m.get('UndertakeStampAreas'):
temp_model = RecognizeAccountPageResponseBodyDataUndertakeStampAreas()
self.undertake_stamp_areas.append(temp_model.from_map(k))
return self
class RecognizeAccountPageResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeAccountPageResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeAccountPageResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeAccountPageResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeAccountPageResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeAccountPageResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeAccountPageResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeAccountPageResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeBankCardRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeBankCardRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeBankCardAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeBankCardAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeBankCardResponseBodyData(TeaModel):
def __init__(self, bank_name=None, card_number=None, valid_date=None):
self.bank_name = bank_name # type: str
self.card_number = card_number # type: str
self.valid_date = valid_date # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeBankCardResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.bank_name is not None:
result['BankName'] = self.bank_name
if self.card_number is not None:
result['CardNumber'] = self.card_number
if self.valid_date is not None:
result['ValidDate'] = self.valid_date
return result
def from_map(self, m=None):
m = m or dict()
if m.get('BankName') is not None:
self.bank_name = m.get('BankName')
if m.get('CardNumber') is not None:
self.card_number = m.get('CardNumber')
if m.get('ValidDate') is not None:
self.valid_date = m.get('ValidDate')
return self
class RecognizeBankCardResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeBankCardResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeBankCardResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeBankCardResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeBankCardResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeBankCardResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeBankCardResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeBankCardResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeBusinessCardRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeBusinessCardRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeBusinessCardAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeBusinessCardAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeBusinessCardResponseBodyData(TeaModel):
def __init__(self, addresses=None, cell_phone_numbers=None, companies=None, departments=None, emails=None,
name=None, office_phone_numbers=None, titles=None):
self.addresses = addresses # type: list[str]
self.cell_phone_numbers = cell_phone_numbers # type: list[str]
self.companies = companies # type: list[str]
self.departments = departments # type: list[str]
self.emails = emails # type: list[str]
self.name = name # type: str
self.office_phone_numbers = office_phone_numbers # type: list[str]
self.titles = titles # type: list[str]
def validate(self):
pass
def to_map(self):
_map = super(RecognizeBusinessCardResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.addresses is not None:
result['Addresses'] = self.addresses
if self.cell_phone_numbers is not None:
result['CellPhoneNumbers'] = self.cell_phone_numbers
if self.companies is not None:
result['Companies'] = self.companies
if self.departments is not None:
result['Departments'] = self.departments
if self.emails is not None:
result['Emails'] = self.emails
if self.name is not None:
result['Name'] = self.name
if self.office_phone_numbers is not None:
result['OfficePhoneNumbers'] = self.office_phone_numbers
if self.titles is not None:
result['Titles'] = self.titles
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Addresses') is not None:
self.addresses = m.get('Addresses')
if m.get('CellPhoneNumbers') is not None:
self.cell_phone_numbers = m.get('CellPhoneNumbers')
if m.get('Companies') is not None:
self.companies = m.get('Companies')
if m.get('Departments') is not None:
self.departments = m.get('Departments')
if m.get('Emails') is not None:
self.emails = m.get('Emails')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('OfficePhoneNumbers') is not None:
self.office_phone_numbers = m.get('OfficePhoneNumbers')
if m.get('Titles') is not None:
self.titles = m.get('Titles')
return self
class RecognizeBusinessCardResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeBusinessCardResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeBusinessCardResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeBusinessCardResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeBusinessCardResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeBusinessCardResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeBusinessCardResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeBusinessCardResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeBusinessLicenseRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeBusinessLicenseRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeBusinessLicenseAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeBusinessLicenseAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeBusinessLicenseResponseBodyDataEmblem(TeaModel):
def __init__(self, height=None, left=None, top=None, width=None):
self.height = height # type: int
self.left = left # type: int
self.top = top # type: int
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeBusinessLicenseResponseBodyDataEmblem, self).to_map()
if _map is not None:
return _map
result = dict()
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeBusinessLicenseResponseBodyDataQRCode(TeaModel):
def __init__(self, height=None, left=None, top=None, width=None):
self.height = height # type: int
self.left = left # type: int
self.top = top # type: int
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeBusinessLicenseResponseBodyDataQRCode, self).to_map()
if _map is not None:
return _map
result = dict()
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeBusinessLicenseResponseBodyDataStamp(TeaModel):
def __init__(self, height=None, left=None, top=None, width=None):
self.height = height # type: int
self.left = left # type: int
self.top = top # type: int
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeBusinessLicenseResponseBodyDataStamp, self).to_map()
if _map is not None:
return _map
result = dict()
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeBusinessLicenseResponseBodyDataTitle(TeaModel):
def __init__(self, height=None, left=None, top=None, width=None):
self.height = height # type: int
self.left = left # type: int
self.top = top # type: int
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeBusinessLicenseResponseBodyDataTitle, self).to_map()
if _map is not None:
return _map
result = dict()
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeBusinessLicenseResponseBodyData(TeaModel):
def __init__(self, address=None, angle=None, business=None, capital=None, emblem=None, establish_date=None,
legal_person=None, name=None, qrcode=None, register_number=None, stamp=None, title=None, type=None,
valid_period=None):
self.address = address # type: str
self.angle = angle # type: float
self.business = business # type: str
self.capital = capital # type: str
self.emblem = emblem # type: RecognizeBusinessLicenseResponseBodyDataEmblem
self.establish_date = establish_date # type: str
self.legal_person = legal_person # type: str
self.name = name # type: str
self.qrcode = qrcode # type: RecognizeBusinessLicenseResponseBodyDataQRCode
self.register_number = register_number # type: str
self.stamp = stamp # type: RecognizeBusinessLicenseResponseBodyDataStamp
self.title = title # type: RecognizeBusinessLicenseResponseBodyDataTitle
self.type = type # type: str
self.valid_period = valid_period # type: str
def validate(self):
if self.emblem:
self.emblem.validate()
if self.qrcode:
self.qrcode.validate()
if self.stamp:
self.stamp.validate()
if self.title:
self.title.validate()
def to_map(self):
_map = super(RecognizeBusinessLicenseResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.address is not None:
result['Address'] = self.address
if self.angle is not None:
result['Angle'] = self.angle
if self.business is not None:
result['Business'] = self.business
if self.capital is not None:
result['Capital'] = self.capital
if self.emblem is not None:
result['Emblem'] = self.emblem.to_map()
if self.establish_date is not None:
result['EstablishDate'] = self.establish_date
if self.legal_person is not None:
result['LegalPerson'] = self.legal_person
if self.name is not None:
result['Name'] = self.name
if self.qrcode is not None:
result['QRCode'] = self.qrcode.to_map()
if self.register_number is not None:
result['RegisterNumber'] = self.register_number
if self.stamp is not None:
result['Stamp'] = self.stamp.to_map()
if self.title is not None:
result['Title'] = self.title.to_map()
if self.type is not None:
result['Type'] = self.type
if self.valid_period is not None:
result['ValidPeriod'] = self.valid_period
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Address') is not None:
self.address = m.get('Address')
if m.get('Angle') is not None:
self.angle = m.get('Angle')
if m.get('Business') is not None:
self.business = m.get('Business')
if m.get('Capital') is not None:
self.capital = m.get('Capital')
if m.get('Emblem') is not None:
temp_model = RecognizeBusinessLicenseResponseBodyDataEmblem()
self.emblem = temp_model.from_map(m['Emblem'])
if m.get('EstablishDate') is not None:
self.establish_date = m.get('EstablishDate')
if m.get('LegalPerson') is not None:
self.legal_person = m.get('LegalPerson')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('QRCode') is not None:
temp_model = RecognizeBusinessLicenseResponseBodyDataQRCode()
self.qrcode = temp_model.from_map(m['QRCode'])
if m.get('RegisterNumber') is not None:
self.register_number = m.get('RegisterNumber')
if m.get('Stamp') is not None:
temp_model = RecognizeBusinessLicenseResponseBodyDataStamp()
self.stamp = temp_model.from_map(m['Stamp'])
if m.get('Title') is not None:
temp_model = RecognizeBusinessLicenseResponseBodyDataTitle()
self.title = temp_model.from_map(m['Title'])
if m.get('Type') is not None:
self.type = m.get('Type')
if m.get('ValidPeriod') is not None:
self.valid_period = m.get('ValidPeriod')
return self
class RecognizeBusinessLicenseResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeBusinessLicenseResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeBusinessLicenseResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeBusinessLicenseResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeBusinessLicenseResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeBusinessLicenseResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeBusinessLicenseResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeBusinessLicenseResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeCharacterRequest(TeaModel):
def __init__(self, image_url=None, min_height=None, output_probability=None):
self.image_url = image_url # type: str
self.min_height = min_height # type: int
self.output_probability = output_probability # type: bool
def validate(self):
pass
def to_map(self):
_map = super(RecognizeCharacterRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
if self.min_height is not None:
result['MinHeight'] = self.min_height
if self.output_probability is not None:
result['OutputProbability'] = self.output_probability
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
if m.get('MinHeight') is not None:
self.min_height = m.get('MinHeight')
if m.get('OutputProbability') is not None:
self.output_probability = m.get('OutputProbability')
return self
class RecognizeCharacterAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None, min_height=None, output_probability=None):
self.image_urlobject = image_urlobject # type: READABLE
self.min_height = min_height # type: int
self.output_probability = output_probability # type: bool
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeCharacterAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
if self.min_height is not None:
result['MinHeight'] = self.min_height
if self.output_probability is not None:
result['OutputProbability'] = self.output_probability
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
if m.get('MinHeight') is not None:
self.min_height = m.get('MinHeight')
if m.get('OutputProbability') is not None:
self.output_probability = m.get('OutputProbability')
return self
class RecognizeCharacterResponseBodyDataResultsTextRectangles(TeaModel):
def __init__(self, angle=None, height=None, left=None, top=None, width=None):
self.angle = angle # type: int
self.height = height # type: int
self.left = left # type: int
self.top = top # type: int
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeCharacterResponseBodyDataResultsTextRectangles, self).to_map()
if _map is not None:
return _map
result = dict()
if self.angle is not None:
result['Angle'] = self.angle
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Angle') is not None:
self.angle = m.get('Angle')
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeCharacterResponseBodyDataResults(TeaModel):
def __init__(self, probability=None, text=None, text_rectangles=None):
self.probability = probability # type: float
self.text = text # type: str
self.text_rectangles = text_rectangles # type: RecognizeCharacterResponseBodyDataResultsTextRectangles
def validate(self):
if self.text_rectangles:
self.text_rectangles.validate()
def to_map(self):
_map = super(RecognizeCharacterResponseBodyDataResults, self).to_map()
if _map is not None:
return _map
result = dict()
if self.probability is not None:
result['Probability'] = self.probability
if self.text is not None:
result['Text'] = self.text
if self.text_rectangles is not None:
result['TextRectangles'] = self.text_rectangles.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Probability') is not None:
self.probability = m.get('Probability')
if m.get('Text') is not None:
self.text = m.get('Text')
if m.get('TextRectangles') is not None:
temp_model = RecognizeCharacterResponseBodyDataResultsTextRectangles()
self.text_rectangles = temp_model.from_map(m['TextRectangles'])
return self
class RecognizeCharacterResponseBodyData(TeaModel):
def __init__(self, results=None):
self.results = results # type: list[RecognizeCharacterResponseBodyDataResults]
def validate(self):
if self.results:
for k in self.results:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeCharacterResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
result['Results'] = []
if self.results is not None:
for k in self.results:
result['Results'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.results = []
if m.get('Results') is not None:
for k in m.get('Results'):
temp_model = RecognizeCharacterResponseBodyDataResults()
self.results.append(temp_model.from_map(k))
return self
class RecognizeCharacterResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeCharacterResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeCharacterResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeCharacterResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeCharacterResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeCharacterResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeCharacterResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeCharacterResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeChinapassportRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeChinapassportRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeChinapassportAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeChinapassportAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeChinapassportResponseBodyData(TeaModel):
def __init__(self, authority=None, birth_date=None, birth_day=None, birth_place=None, birth_place_raw=None,
country=None, expiry_date=None, expiry_day=None, issue_date=None, issue_place=None, issue_place_raw=None,
line_one=None, line_zero=None, name=None, name_chinese=None, name_chinese_raw=None, passport_no=None,
person_id=None, sex=None, source_country=None, success=None, type=None):
self.authority = authority # type: str
self.birth_date = birth_date # type: str
self.birth_day = birth_day # type: str
self.birth_place = birth_place # type: str
self.birth_place_raw = birth_place_raw # type: str
self.country = country # type: str
self.expiry_date = expiry_date # type: str
self.expiry_day = expiry_day # type: str
self.issue_date = issue_date # type: str
self.issue_place = issue_place # type: str
self.issue_place_raw = issue_place_raw # type: str
self.line_one = line_one # type: str
self.line_zero = line_zero # type: str
self.name = name # type: str
self.name_chinese = name_chinese # type: str
self.name_chinese_raw = name_chinese_raw # type: str
self.passport_no = passport_no # type: str
self.person_id = person_id # type: str
self.sex = sex # type: str
self.source_country = source_country # type: str
self.success = success # type: bool
self.type = type # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeChinapassportResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.authority is not None:
result['Authority'] = self.authority
if self.birth_date is not None:
result['BirthDate'] = self.birth_date
if self.birth_day is not None:
result['BirthDay'] = self.birth_day
if self.birth_place is not None:
result['BirthPlace'] = self.birth_place
if self.birth_place_raw is not None:
result['BirthPlaceRaw'] = self.birth_place_raw
if self.country is not None:
result['Country'] = self.country
if self.expiry_date is not None:
result['ExpiryDate'] = self.expiry_date
if self.expiry_day is not None:
result['ExpiryDay'] = self.expiry_day
if self.issue_date is not None:
result['IssueDate'] = self.issue_date
if self.issue_place is not None:
result['IssuePlace'] = self.issue_place
if self.issue_place_raw is not None:
result['IssuePlaceRaw'] = self.issue_place_raw
if self.line_one is not None:
result['LineOne'] = self.line_one
if self.line_zero is not None:
result['LineZero'] = self.line_zero
if self.name is not None:
result['Name'] = self.name
if self.name_chinese is not None:
result['NameChinese'] = self.name_chinese
if self.name_chinese_raw is not None:
result['NameChineseRaw'] = self.name_chinese_raw
if self.passport_no is not None:
result['PassportNo'] = self.passport_no
if self.person_id is not None:
result['PersonId'] = self.person_id
if self.sex is not None:
result['Sex'] = self.sex
if self.source_country is not None:
result['SourceCountry'] = self.source_country
if self.success is not None:
result['Success'] = self.success
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Authority') is not None:
self.authority = m.get('Authority')
if m.get('BirthDate') is not None:
self.birth_date = m.get('BirthDate')
if m.get('BirthDay') is not None:
self.birth_day = m.get('BirthDay')
if m.get('BirthPlace') is not None:
self.birth_place = m.get('BirthPlace')
if m.get('BirthPlaceRaw') is not None:
self.birth_place_raw = m.get('BirthPlaceRaw')
if m.get('Country') is not None:
self.country = m.get('Country')
if m.get('ExpiryDate') is not None:
self.expiry_date = m.get('ExpiryDate')
if m.get('ExpiryDay') is not None:
self.expiry_day = m.get('ExpiryDay')
if m.get('IssueDate') is not None:
self.issue_date = m.get('IssueDate')
if m.get('IssuePlace') is not None:
self.issue_place = m.get('IssuePlace')
if m.get('IssuePlaceRaw') is not None:
self.issue_place_raw = m.get('IssuePlaceRaw')
if m.get('LineOne') is not None:
self.line_one = m.get('LineOne')
if m.get('LineZero') is not None:
self.line_zero = m.get('LineZero')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('NameChinese') is not None:
self.name_chinese = m.get('NameChinese')
if m.get('NameChineseRaw') is not None:
self.name_chinese_raw = m.get('NameChineseRaw')
if m.get('PassportNo') is not None:
self.passport_no = m.get('PassportNo')
if m.get('PersonId') is not None:
self.person_id = m.get('PersonId')
if m.get('Sex') is not None:
self.sex = m.get('Sex')
if m.get('SourceCountry') is not None:
self.source_country = m.get('SourceCountry')
if m.get('Success') is not None:
self.success = m.get('Success')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class RecognizeChinapassportResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeChinapassportResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeChinapassportResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeChinapassportResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeChinapassportResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeChinapassportResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeChinapassportResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeChinapassportResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeDriverLicenseRequest(TeaModel):
def __init__(self, image_url=None, side=None):
self.image_url = image_url # type: str
self.side = side # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeDriverLicenseRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
if self.side is not None:
result['Side'] = self.side
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
if m.get('Side') is not None:
self.side = m.get('Side')
return self
class RecognizeDriverLicenseAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None, side=None):
self.image_urlobject = image_urlobject # type: READABLE
self.side = side # type: str
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeDriverLicenseAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
if self.side is not None:
result['Side'] = self.side
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
if m.get('Side') is not None:
self.side = m.get('Side')
return self
class RecognizeDriverLicenseResponseBodyDataBackResult(TeaModel):
def __init__(self, archive_number=None, card_number=None, name=None, record=None):
self.archive_number = archive_number # type: str
self.card_number = card_number # type: str
self.name = name # type: str
self.record = record # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeDriverLicenseResponseBodyDataBackResult, self).to_map()
if _map is not None:
return _map
result = dict()
if self.archive_number is not None:
result['ArchiveNumber'] = self.archive_number
if self.card_number is not None:
result['CardNumber'] = self.card_number
if self.name is not None:
result['Name'] = self.name
if self.record is not None:
result['Record'] = self.record
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ArchiveNumber') is not None:
self.archive_number = m.get('ArchiveNumber')
if m.get('CardNumber') is not None:
self.card_number = m.get('CardNumber')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Record') is not None:
self.record = m.get('Record')
return self
class RecognizeDriverLicenseResponseBodyDataFaceResult(TeaModel):
def __init__(self, address=None, end_date=None, gender=None, issue_date=None, issue_unit=None,
license_number=None, name=None, start_date=None, vehicle_type=None):
self.address = address # type: str
self.end_date = end_date # type: str
self.gender = gender # type: str
self.issue_date = issue_date # type: str
self.issue_unit = issue_unit # type: str
self.license_number = license_number # type: str
self.name = name # type: str
self.start_date = start_date # type: str
self.vehicle_type = vehicle_type # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeDriverLicenseResponseBodyDataFaceResult, self).to_map()
if _map is not None:
return _map
result = dict()
if self.address is not None:
result['Address'] = self.address
if self.end_date is not None:
result['EndDate'] = self.end_date
if self.gender is not None:
result['Gender'] = self.gender
if self.issue_date is not None:
result['IssueDate'] = self.issue_date
if self.issue_unit is not None:
result['IssueUnit'] = self.issue_unit
if self.license_number is not None:
result['LicenseNumber'] = self.license_number
if self.name is not None:
result['Name'] = self.name
if self.start_date is not None:
result['StartDate'] = self.start_date
if self.vehicle_type is not None:
result['VehicleType'] = self.vehicle_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Address') is not None:
self.address = m.get('Address')
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
if m.get('Gender') is not None:
self.gender = m.get('Gender')
if m.get('IssueDate') is not None:
self.issue_date = m.get('IssueDate')
if m.get('IssueUnit') is not None:
self.issue_unit = m.get('IssueUnit')
if m.get('LicenseNumber') is not None:
self.license_number = m.get('LicenseNumber')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
if m.get('VehicleType') is not None:
self.vehicle_type = m.get('VehicleType')
return self
class RecognizeDriverLicenseResponseBodyData(TeaModel):
def __init__(self, back_result=None, face_result=None):
self.back_result = back_result # type: RecognizeDriverLicenseResponseBodyDataBackResult
self.face_result = face_result # type: RecognizeDriverLicenseResponseBodyDataFaceResult
def validate(self):
if self.back_result:
self.back_result.validate()
if self.face_result:
self.face_result.validate()
def to_map(self):
_map = super(RecognizeDriverLicenseResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.back_result is not None:
result['BackResult'] = self.back_result.to_map()
if self.face_result is not None:
result['FaceResult'] = self.face_result.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('BackResult') is not None:
temp_model = RecognizeDriverLicenseResponseBodyDataBackResult()
self.back_result = temp_model.from_map(m['BackResult'])
if m.get('FaceResult') is not None:
temp_model = RecognizeDriverLicenseResponseBodyDataFaceResult()
self.face_result = temp_model.from_map(m['FaceResult'])
return self
class RecognizeDriverLicenseResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeDriverLicenseResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeDriverLicenseResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeDriverLicenseResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeDriverLicenseResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeDriverLicenseResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeDriverLicenseResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeDriverLicenseResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeDrivingLicenseRequest(TeaModel):
def __init__(self, image_url=None, side=None):
self.image_url = image_url # type: str
self.side = side # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeDrivingLicenseRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
if self.side is not None:
result['Side'] = self.side
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
if m.get('Side') is not None:
self.side = m.get('Side')
return self
class RecognizeDrivingLicenseAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None, side=None):
self.image_urlobject = image_urlobject # type: READABLE
self.side = side # type: str
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeDrivingLicenseAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
if self.side is not None:
result['Side'] = self.side
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
if m.get('Side') is not None:
self.side = m.get('Side')
return self
class RecognizeDrivingLicenseResponseBodyDataBackResult(TeaModel):
def __init__(self, approved_load=None, approved_passenger_capacity=None, energy_type=None, file_number=None,
gross_mass=None, inspection_record=None, overall_dimension=None, plate_number=None, traction_mass=None,
unladen_mass=None):
self.approved_load = approved_load # type: str
self.approved_passenger_capacity = approved_passenger_capacity # type: str
self.energy_type = energy_type # type: str
self.file_number = file_number # type: str
self.gross_mass = gross_mass # type: str
self.inspection_record = inspection_record # type: str
self.overall_dimension = overall_dimension # type: str
self.plate_number = plate_number # type: str
self.traction_mass = traction_mass # type: str
self.unladen_mass = unladen_mass # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeDrivingLicenseResponseBodyDataBackResult, self).to_map()
if _map is not None:
return _map
result = dict()
if self.approved_load is not None:
result['ApprovedLoad'] = self.approved_load
if self.approved_passenger_capacity is not None:
result['ApprovedPassengerCapacity'] = self.approved_passenger_capacity
if self.energy_type is not None:
result['EnergyType'] = self.energy_type
if self.file_number is not None:
result['FileNumber'] = self.file_number
if self.gross_mass is not None:
result['GrossMass'] = self.gross_mass
if self.inspection_record is not None:
result['InspectionRecord'] = self.inspection_record
if self.overall_dimension is not None:
result['OverallDimension'] = self.overall_dimension
if self.plate_number is not None:
result['PlateNumber'] = self.plate_number
if self.traction_mass is not None:
result['TractionMass'] = self.traction_mass
if self.unladen_mass is not None:
result['UnladenMass'] = self.unladen_mass
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ApprovedLoad') is not None:
self.approved_load = m.get('ApprovedLoad')
if m.get('ApprovedPassengerCapacity') is not None:
self.approved_passenger_capacity = m.get('ApprovedPassengerCapacity')
if m.get('EnergyType') is not None:
self.energy_type = m.get('EnergyType')
if m.get('FileNumber') is not None:
self.file_number = m.get('FileNumber')
if m.get('GrossMass') is not None:
self.gross_mass = m.get('GrossMass')
if m.get('InspectionRecord') is not None:
self.inspection_record = m.get('InspectionRecord')
if m.get('OverallDimension') is not None:
self.overall_dimension = m.get('OverallDimension')
if m.get('PlateNumber') is not None:
self.plate_number = m.get('PlateNumber')
if m.get('TractionMass') is not None:
self.traction_mass = m.get('TractionMass')
if m.get('UnladenMass') is not None:
self.unladen_mass = m.get('UnladenMass')
return self
class RecognizeDrivingLicenseResponseBodyDataFaceResult(TeaModel):
def __init__(self, address=None, engine_number=None, issue_date=None, model=None, owner=None, plate_number=None,
register_date=None, use_character=None, vehicle_type=None, vin=None):
self.address = address # type: str
self.engine_number = engine_number # type: str
self.issue_date = issue_date # type: str
self.model = model # type: str
self.owner = owner # type: str
self.plate_number = plate_number # type: str
self.register_date = register_date # type: str
self.use_character = use_character # type: str
self.vehicle_type = vehicle_type # type: str
self.vin = vin # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeDrivingLicenseResponseBodyDataFaceResult, self).to_map()
if _map is not None:
return _map
result = dict()
if self.address is not None:
result['Address'] = self.address
if self.engine_number is not None:
result['EngineNumber'] = self.engine_number
if self.issue_date is not None:
result['IssueDate'] = self.issue_date
if self.model is not None:
result['Model'] = self.model
if self.owner is not None:
result['Owner'] = self.owner
if self.plate_number is not None:
result['PlateNumber'] = self.plate_number
if self.register_date is not None:
result['RegisterDate'] = self.register_date
if self.use_character is not None:
result['UseCharacter'] = self.use_character
if self.vehicle_type is not None:
result['VehicleType'] = self.vehicle_type
if self.vin is not None:
result['Vin'] = self.vin
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Address') is not None:
self.address = m.get('Address')
if m.get('EngineNumber') is not None:
self.engine_number = m.get('EngineNumber')
if m.get('IssueDate') is not None:
self.issue_date = m.get('IssueDate')
if m.get('Model') is not None:
self.model = m.get('Model')
if m.get('Owner') is not None:
self.owner = m.get('Owner')
if m.get('PlateNumber') is not None:
self.plate_number = m.get('PlateNumber')
if m.get('RegisterDate') is not None:
self.register_date = m.get('RegisterDate')
if m.get('UseCharacter') is not None:
self.use_character = m.get('UseCharacter')
if m.get('VehicleType') is not None:
self.vehicle_type = m.get('VehicleType')
if m.get('Vin') is not None:
self.vin = m.get('Vin')
return self
class RecognizeDrivingLicenseResponseBodyData(TeaModel):
def __init__(self, back_result=None, face_result=None):
self.back_result = back_result # type: RecognizeDrivingLicenseResponseBodyDataBackResult
self.face_result = face_result # type: RecognizeDrivingLicenseResponseBodyDataFaceResult
def validate(self):
if self.back_result:
self.back_result.validate()
if self.face_result:
self.face_result.validate()
def to_map(self):
_map = super(RecognizeDrivingLicenseResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.back_result is not None:
result['BackResult'] = self.back_result.to_map()
if self.face_result is not None:
result['FaceResult'] = self.face_result.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('BackResult') is not None:
temp_model = RecognizeDrivingLicenseResponseBodyDataBackResult()
self.back_result = temp_model.from_map(m['BackResult'])
if m.get('FaceResult') is not None:
temp_model = RecognizeDrivingLicenseResponseBodyDataFaceResult()
self.face_result = temp_model.from_map(m['FaceResult'])
return self
class RecognizeDrivingLicenseResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeDrivingLicenseResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeDrivingLicenseResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeDrivingLicenseResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeDrivingLicenseResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeDrivingLicenseResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeDrivingLicenseResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeDrivingLicenseResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeIdentityCardRequest(TeaModel):
def __init__(self, image_url=None, side=None):
self.image_url = image_url # type: str
self.side = side # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeIdentityCardRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
if self.side is not None:
result['Side'] = self.side
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
if m.get('Side') is not None:
self.side = m.get('Side')
return self
class RecognizeIdentityCardAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None, side=None):
self.image_urlobject = image_urlobject # type: READABLE
self.side = side # type: str
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeIdentityCardAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
if self.side is not None:
result['Side'] = self.side
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
if m.get('Side') is not None:
self.side = m.get('Side')
return self
class RecognizeIdentityCardResponseBodyDataBackResult(TeaModel):
def __init__(self, end_date=None, issue=None, start_date=None):
self.end_date = end_date # type: str
self.issue = issue # type: str
self.start_date = start_date # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeIdentityCardResponseBodyDataBackResult, self).to_map()
if _map is not None:
return _map
result = dict()
if self.end_date is not None:
result['EndDate'] = self.end_date
if self.issue is not None:
result['Issue'] = self.issue
if self.start_date is not None:
result['StartDate'] = self.start_date
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EndDate') is not None:
self.end_date = m.get('EndDate')
if m.get('Issue') is not None:
self.issue = m.get('Issue')
if m.get('StartDate') is not None:
self.start_date = m.get('StartDate')
return self
class RecognizeIdentityCardResponseBodyDataFrontResultCardAreas(TeaModel):
def __init__(self, x=None, y=None):
self.x = x # type: float
self.y = y # type: float
def validate(self):
pass
def to_map(self):
_map = super(RecognizeIdentityCardResponseBodyDataFrontResultCardAreas, self).to_map()
if _map is not None:
return _map
result = dict()
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizeIdentityCardResponseBodyDataFrontResultFaceRectVertices(TeaModel):
def __init__(self, x=None, y=None):
self.x = x # type: float
self.y = y # type: float
def validate(self):
pass
def to_map(self):
_map = super(RecognizeIdentityCardResponseBodyDataFrontResultFaceRectVertices, self).to_map()
if _map is not None:
return _map
result = dict()
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangleCenter(TeaModel):
def __init__(self, x=None, y=None):
self.x = x # type: float
self.y = y # type: float
def validate(self):
pass
def to_map(self):
_map = super(RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangleCenter, self).to_map()
if _map is not None:
return _map
result = dict()
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangleSize(TeaModel):
def __init__(self, height=None, width=None):
self.height = height # type: float
self.width = width # type: float
def validate(self):
pass
def to_map(self):
_map = super(RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangleSize, self).to_map()
if _map is not None:
return _map
result = dict()
if self.height is not None:
result['Height'] = self.height
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangle(TeaModel):
def __init__(self, angle=None, center=None, size=None):
self.angle = angle # type: float
self.center = center # type: RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangleCenter
self.size = size # type: RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangleSize
def validate(self):
if self.center:
self.center.validate()
if self.size:
self.size.validate()
def to_map(self):
_map = super(RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangle, self).to_map()
if _map is not None:
return _map
result = dict()
if self.angle is not None:
result['Angle'] = self.angle
if self.center is not None:
result['Center'] = self.center.to_map()
if self.size is not None:
result['Size'] = self.size.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Angle') is not None:
self.angle = m.get('Angle')
if m.get('Center') is not None:
temp_model = RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangleCenter()
self.center = temp_model.from_map(m['Center'])
if m.get('Size') is not None:
temp_model = RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangleSize()
self.size = temp_model.from_map(m['Size'])
return self
class RecognizeIdentityCardResponseBodyDataFrontResult(TeaModel):
def __init__(self, address=None, birth_date=None, card_areas=None, face_rect_vertices=None, face_rectangle=None,
gender=None, idnumber=None, name=None, nationality=None):
self.address = address # type: str
self.birth_date = birth_date # type: str
self.card_areas = card_areas # type: list[RecognizeIdentityCardResponseBodyDataFrontResultCardAreas]
self.face_rect_vertices = face_rect_vertices # type: list[RecognizeIdentityCardResponseBodyDataFrontResultFaceRectVertices]
self.face_rectangle = face_rectangle # type: RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangle
self.gender = gender # type: str
self.idnumber = idnumber # type: str
self.name = name # type: str
self.nationality = nationality # type: str
def validate(self):
if self.card_areas:
for k in self.card_areas:
if k:
k.validate()
if self.face_rect_vertices:
for k in self.face_rect_vertices:
if k:
k.validate()
if self.face_rectangle:
self.face_rectangle.validate()
def to_map(self):
_map = super(RecognizeIdentityCardResponseBodyDataFrontResult, self).to_map()
if _map is not None:
return _map
result = dict()
if self.address is not None:
result['Address'] = self.address
if self.birth_date is not None:
result['BirthDate'] = self.birth_date
result['CardAreas'] = []
if self.card_areas is not None:
for k in self.card_areas:
result['CardAreas'].append(k.to_map() if k else None)
result['FaceRectVertices'] = []
if self.face_rect_vertices is not None:
for k in self.face_rect_vertices:
result['FaceRectVertices'].append(k.to_map() if k else None)
if self.face_rectangle is not None:
result['FaceRectangle'] = self.face_rectangle.to_map()
if self.gender is not None:
result['Gender'] = self.gender
if self.idnumber is not None:
result['IDNumber'] = self.idnumber
if self.name is not None:
result['Name'] = self.name
if self.nationality is not None:
result['Nationality'] = self.nationality
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Address') is not None:
self.address = m.get('Address')
if m.get('BirthDate') is not None:
self.birth_date = m.get('BirthDate')
self.card_areas = []
if m.get('CardAreas') is not None:
for k in m.get('CardAreas'):
temp_model = RecognizeIdentityCardResponseBodyDataFrontResultCardAreas()
self.card_areas.append(temp_model.from_map(k))
self.face_rect_vertices = []
if m.get('FaceRectVertices') is not None:
for k in m.get('FaceRectVertices'):
temp_model = RecognizeIdentityCardResponseBodyDataFrontResultFaceRectVertices()
self.face_rect_vertices.append(temp_model.from_map(k))
if m.get('FaceRectangle') is not None:
temp_model = RecognizeIdentityCardResponseBodyDataFrontResultFaceRectangle()
self.face_rectangle = temp_model.from_map(m['FaceRectangle'])
if m.get('Gender') is not None:
self.gender = m.get('Gender')
if m.get('IDNumber') is not None:
self.idnumber = m.get('IDNumber')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Nationality') is not None:
self.nationality = m.get('Nationality')
return self
class RecognizeIdentityCardResponseBodyData(TeaModel):
def __init__(self, back_result=None, front_result=None):
self.back_result = back_result # type: RecognizeIdentityCardResponseBodyDataBackResult
self.front_result = front_result # type: RecognizeIdentityCardResponseBodyDataFrontResult
def validate(self):
if self.back_result:
self.back_result.validate()
if self.front_result:
self.front_result.validate()
def to_map(self):
_map = super(RecognizeIdentityCardResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.back_result is not None:
result['BackResult'] = self.back_result.to_map()
if self.front_result is not None:
result['FrontResult'] = self.front_result.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('BackResult') is not None:
temp_model = RecognizeIdentityCardResponseBodyDataBackResult()
self.back_result = temp_model.from_map(m['BackResult'])
if m.get('FrontResult') is not None:
temp_model = RecognizeIdentityCardResponseBodyDataFrontResult()
self.front_result = temp_model.from_map(m['FrontResult'])
return self
class RecognizeIdentityCardResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeIdentityCardResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeIdentityCardResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeIdentityCardResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeIdentityCardResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeIdentityCardResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeIdentityCardResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeIdentityCardResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeLicensePlateRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeLicensePlateRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeLicensePlateAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeLicensePlateAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeLicensePlateResponseBodyDataPlatesPositions(TeaModel):
def __init__(self, x=None, y=None):
self.x = x # type: long
self.y = y # type: long
def validate(self):
pass
def to_map(self):
_map = super(RecognizeLicensePlateResponseBodyDataPlatesPositions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizeLicensePlateResponseBodyDataPlatesRoi(TeaModel):
def __init__(self, h=None, w=None, x=None, y=None):
self.h = h # type: int
self.w = w # type: int
self.x = x # type: int
self.y = y # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeLicensePlateResponseBodyDataPlatesRoi, self).to_map()
if _map is not None:
return _map
result = dict()
if self.h is not None:
result['H'] = self.h
if self.w is not None:
result['W'] = self.w
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('H') is not None:
self.h = m.get('H')
if m.get('W') is not None:
self.w = m.get('W')
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizeLicensePlateResponseBodyDataPlates(TeaModel):
def __init__(self, confidence=None, plate_number=None, plate_type=None, plate_type_confidence=None,
positions=None, roi=None):
self.confidence = confidence # type: float
self.plate_number = plate_number # type: str
self.plate_type = plate_type # type: str
self.plate_type_confidence = plate_type_confidence # type: float
self.positions = positions # type: list[RecognizeLicensePlateResponseBodyDataPlatesPositions]
self.roi = roi # type: RecognizeLicensePlateResponseBodyDataPlatesRoi
def validate(self):
if self.positions:
for k in self.positions:
if k:
k.validate()
if self.roi:
self.roi.validate()
def to_map(self):
_map = super(RecognizeLicensePlateResponseBodyDataPlates, self).to_map()
if _map is not None:
return _map
result = dict()
if self.confidence is not None:
result['Confidence'] = self.confidence
if self.plate_number is not None:
result['PlateNumber'] = self.plate_number
if self.plate_type is not None:
result['PlateType'] = self.plate_type
if self.plate_type_confidence is not None:
result['PlateTypeConfidence'] = self.plate_type_confidence
result['Positions'] = []
if self.positions is not None:
for k in self.positions:
result['Positions'].append(k.to_map() if k else None)
if self.roi is not None:
result['Roi'] = self.roi.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Confidence') is not None:
self.confidence = m.get('Confidence')
if m.get('PlateNumber') is not None:
self.plate_number = m.get('PlateNumber')
if m.get('PlateType') is not None:
self.plate_type = m.get('PlateType')
if m.get('PlateTypeConfidence') is not None:
self.plate_type_confidence = m.get('PlateTypeConfidence')
self.positions = []
if m.get('Positions') is not None:
for k in m.get('Positions'):
temp_model = RecognizeLicensePlateResponseBodyDataPlatesPositions()
self.positions.append(temp_model.from_map(k))
if m.get('Roi') is not None:
temp_model = RecognizeLicensePlateResponseBodyDataPlatesRoi()
self.roi = temp_model.from_map(m['Roi'])
return self
class RecognizeLicensePlateResponseBodyData(TeaModel):
def __init__(self, plates=None):
self.plates = plates # type: list[RecognizeLicensePlateResponseBodyDataPlates]
def validate(self):
if self.plates:
for k in self.plates:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeLicensePlateResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
result['Plates'] = []
if self.plates is not None:
for k in self.plates:
result['Plates'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.plates = []
if m.get('Plates') is not None:
for k in m.get('Plates'):
temp_model = RecognizeLicensePlateResponseBodyDataPlates()
self.plates.append(temp_model.from_map(k))
return self
class RecognizeLicensePlateResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeLicensePlateResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeLicensePlateResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeLicensePlateResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeLicensePlateResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeLicensePlateResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeLicensePlateResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeLicensePlateResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizePassportMRZRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizePassportMRZRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizePassportMRZAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizePassportMRZAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizePassportMRZResponseBodyDataRegions(TeaModel):
def __init__(self, band_boxes=None, content=None, detection_score=None, name=None, recognition_score=None):
self.band_boxes = band_boxes # type: list[float]
self.content = content # type: str
self.detection_score = detection_score # type: float
self.name = name # type: str
self.recognition_score = recognition_score # type: float
def validate(self):
pass
def to_map(self):
_map = super(RecognizePassportMRZResponseBodyDataRegions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.band_boxes is not None:
result['BandBoxes'] = self.band_boxes
if self.content is not None:
result['Content'] = self.content
if self.detection_score is not None:
result['DetectionScore'] = self.detection_score
if self.name is not None:
result['Name'] = self.name
if self.recognition_score is not None:
result['RecognitionScore'] = self.recognition_score
return result
def from_map(self, m=None):
m = m or dict()
if m.get('BandBoxes') is not None:
self.band_boxes = m.get('BandBoxes')
if m.get('Content') is not None:
self.content = m.get('Content')
if m.get('DetectionScore') is not None:
self.detection_score = m.get('DetectionScore')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('RecognitionScore') is not None:
self.recognition_score = m.get('RecognitionScore')
return self
class RecognizePassportMRZResponseBodyData(TeaModel):
def __init__(self, regions=None):
self.regions = regions # type: list[RecognizePassportMRZResponseBodyDataRegions]
def validate(self):
if self.regions:
for k in self.regions:
if k:
k.validate()
def to_map(self):
_map = super(RecognizePassportMRZResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
result['Regions'] = []
if self.regions is not None:
for k in self.regions:
result['Regions'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.regions = []
if m.get('Regions') is not None:
for k in m.get('Regions'):
temp_model = RecognizePassportMRZResponseBodyDataRegions()
self.regions.append(temp_model.from_map(k))
return self
class RecognizePassportMRZResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizePassportMRZResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizePassportMRZResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizePassportMRZResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizePassportMRZResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizePassportMRZResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizePassportMRZResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizePassportMRZResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizePdfRequest(TeaModel):
def __init__(self, file_url=None):
# A short description of struct
self.file_url = file_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizePdfRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.file_url is not None:
result['FileURL'] = self.file_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('FileURL') is not None:
self.file_url = m.get('FileURL')
return self
class RecognizePdfAdvanceRequest(TeaModel):
def __init__(self, file_urlobject=None):
self.file_urlobject = file_urlobject # type: READABLE
def validate(self):
self.validate_required(self.file_urlobject, 'file_urlobject')
def to_map(self):
_map = super(RecognizePdfAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.file_urlobject is not None:
result['FileURLObject'] = self.file_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('FileURLObject') is not None:
self.file_urlobject = m.get('FileURLObject')
return self
class RecognizePdfResponseBodyDataWordsInfoPositions(TeaModel):
def __init__(self, x=None, y=None):
self.x = x # type: long
self.y = y # type: long
def validate(self):
pass
def to_map(self):
_map = super(RecognizePdfResponseBodyDataWordsInfoPositions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizePdfResponseBodyDataWordsInfo(TeaModel):
def __init__(self, angle=None, height=None, positions=None, width=None, word=None, x=None, y=None):
self.angle = angle # type: long
self.height = height # type: long
self.positions = positions # type: list[RecognizePdfResponseBodyDataWordsInfoPositions]
self.width = width # type: long
self.word = word # type: str
self.x = x # type: long
self.y = y # type: long
def validate(self):
if self.positions:
for k in self.positions:
if k:
k.validate()
def to_map(self):
_map = super(RecognizePdfResponseBodyDataWordsInfo, self).to_map()
if _map is not None:
return _map
result = dict()
if self.angle is not None:
result['Angle'] = self.angle
if self.height is not None:
result['Height'] = self.height
result['Positions'] = []
if self.positions is not None:
for k in self.positions:
result['Positions'].append(k.to_map() if k else None)
if self.width is not None:
result['Width'] = self.width
if self.word is not None:
result['Word'] = self.word
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Angle') is not None:
self.angle = m.get('Angle')
if m.get('Height') is not None:
self.height = m.get('Height')
self.positions = []
if m.get('Positions') is not None:
for k in m.get('Positions'):
temp_model = RecognizePdfResponseBodyDataWordsInfoPositions()
self.positions.append(temp_model.from_map(k))
if m.get('Width') is not None:
self.width = m.get('Width')
if m.get('Word') is not None:
self.word = m.get('Word')
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizePdfResponseBodyData(TeaModel):
def __init__(self, angle=None, height=None, org_height=None, org_width=None, page_index=None, width=None,
words_info=None):
self.angle = angle # type: long
self.height = height # type: long
self.org_height = org_height # type: long
self.org_width = org_width # type: long
self.page_index = page_index # type: long
self.width = width # type: long
self.words_info = words_info # type: list[RecognizePdfResponseBodyDataWordsInfo]
def validate(self):
if self.words_info:
for k in self.words_info:
if k:
k.validate()
def to_map(self):
_map = super(RecognizePdfResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.angle is not None:
result['Angle'] = self.angle
if self.height is not None:
result['Height'] = self.height
if self.org_height is not None:
result['OrgHeight'] = self.org_height
if self.org_width is not None:
result['OrgWidth'] = self.org_width
if self.page_index is not None:
result['PageIndex'] = self.page_index
if self.width is not None:
result['Width'] = self.width
result['WordsInfo'] = []
if self.words_info is not None:
for k in self.words_info:
result['WordsInfo'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Angle') is not None:
self.angle = m.get('Angle')
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('OrgHeight') is not None:
self.org_height = m.get('OrgHeight')
if m.get('OrgWidth') is not None:
self.org_width = m.get('OrgWidth')
if m.get('PageIndex') is not None:
self.page_index = m.get('PageIndex')
if m.get('Width') is not None:
self.width = m.get('Width')
self.words_info = []
if m.get('WordsInfo') is not None:
for k in m.get('WordsInfo'):
temp_model = RecognizePdfResponseBodyDataWordsInfo()
self.words_info.append(temp_model.from_map(k))
return self
class RecognizePdfResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizePdfResponseBodyData
# Id of the request
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizePdfResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizePdfResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizePdfResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizePdfResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizePdfResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizePdfResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizePoiNameRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizePoiNameRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizePoiNameAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizePoiNameAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizePoiNameResponseBodyDataSignboardsTexts(TeaModel):
def __init__(self, label=None, points=None, score=None, tag=None, type=None):
self.label = label # type: str
self.points = points # type: list[int]
self.score = score # type: float
self.tag = tag # type: str
self.type = type # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizePoiNameResponseBodyDataSignboardsTexts, self).to_map()
if _map is not None:
return _map
result = dict()
if self.label is not None:
result['Label'] = self.label
if self.points is not None:
result['Points'] = self.points
if self.score is not None:
result['Score'] = self.score
if self.tag is not None:
result['Tag'] = self.tag
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Label') is not None:
self.label = m.get('Label')
if m.get('Points') is not None:
self.points = m.get('Points')
if m.get('Score') is not None:
self.score = m.get('Score')
if m.get('Tag') is not None:
self.tag = m.get('Tag')
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class RecognizePoiNameResponseBodyDataSignboards(TeaModel):
def __init__(self, texts=None):
self.texts = texts # type: list[RecognizePoiNameResponseBodyDataSignboardsTexts]
def validate(self):
if self.texts:
for k in self.texts:
if k:
k.validate()
def to_map(self):
_map = super(RecognizePoiNameResponseBodyDataSignboards, self).to_map()
if _map is not None:
return _map
result = dict()
result['Texts'] = []
if self.texts is not None:
for k in self.texts:
result['Texts'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.texts = []
if m.get('Texts') is not None:
for k in m.get('Texts'):
temp_model = RecognizePoiNameResponseBodyDataSignboardsTexts()
self.texts.append(temp_model.from_map(k))
return self
class RecognizePoiNameResponseBodyDataSummary(TeaModel):
def __init__(self, brand=None, score=None):
self.brand = brand # type: str
self.score = score # type: float
def validate(self):
pass
def to_map(self):
_map = super(RecognizePoiNameResponseBodyDataSummary, self).to_map()
if _map is not None:
return _map
result = dict()
if self.brand is not None:
result['Brand'] = self.brand
if self.score is not None:
result['Score'] = self.score
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Brand') is not None:
self.brand = m.get('Brand')
if m.get('Score') is not None:
self.score = m.get('Score')
return self
class RecognizePoiNameResponseBodyData(TeaModel):
def __init__(self, signboards=None, summary=None):
self.signboards = signboards # type: list[RecognizePoiNameResponseBodyDataSignboards]
self.summary = summary # type: RecognizePoiNameResponseBodyDataSummary
def validate(self):
if self.signboards:
for k in self.signboards:
if k:
k.validate()
if self.summary:
self.summary.validate()
def to_map(self):
_map = super(RecognizePoiNameResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
result['Signboards'] = []
if self.signboards is not None:
for k in self.signboards:
result['Signboards'].append(k.to_map() if k else None)
if self.summary is not None:
result['Summary'] = self.summary.to_map()
return result
def from_map(self, m=None):
m = m or dict()
self.signboards = []
if m.get('Signboards') is not None:
for k in m.get('Signboards'):
temp_model = RecognizePoiNameResponseBodyDataSignboards()
self.signboards.append(temp_model.from_map(k))
if m.get('Summary') is not None:
temp_model = RecognizePoiNameResponseBodyDataSummary()
self.summary = temp_model.from_map(m['Summary'])
return self
class RecognizePoiNameResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizePoiNameResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizePoiNameResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizePoiNameResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizePoiNameResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizePoiNameResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizePoiNameResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizePoiNameResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeQrCodeRequestTasks(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeQrCodeRequestTasks, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeQrCodeRequest(TeaModel):
def __init__(self, tasks=None):
self.tasks = tasks # type: list[RecognizeQrCodeRequestTasks]
def validate(self):
if self.tasks:
for k in self.tasks:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeQrCodeRequest, self).to_map()
if _map is not None:
return _map
result = dict()
result['Tasks'] = []
if self.tasks is not None:
for k in self.tasks:
result['Tasks'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.tasks = []
if m.get('Tasks') is not None:
for k in m.get('Tasks'):
temp_model = RecognizeQrCodeRequestTasks()
self.tasks.append(temp_model.from_map(k))
return self
class RecognizeQrCodeResponseBodyDataElementsResults(TeaModel):
def __init__(self, label=None, qr_codes_data=None, rate=None, suggestion=None):
self.label = label # type: str
self.qr_codes_data = qr_codes_data # type: list[str]
self.rate = rate # type: float
self.suggestion = suggestion # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeQrCodeResponseBodyDataElementsResults, self).to_map()
if _map is not None:
return _map
result = dict()
if self.label is not None:
result['Label'] = self.label
if self.qr_codes_data is not None:
result['QrCodesData'] = self.qr_codes_data
if self.rate is not None:
result['Rate'] = self.rate
if self.suggestion is not None:
result['Suggestion'] = self.suggestion
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Label') is not None:
self.label = m.get('Label')
if m.get('QrCodesData') is not None:
self.qr_codes_data = m.get('QrCodesData')
if m.get('Rate') is not None:
self.rate = m.get('Rate')
if m.get('Suggestion') is not None:
self.suggestion = m.get('Suggestion')
return self
class RecognizeQrCodeResponseBodyDataElements(TeaModel):
def __init__(self, image_url=None, results=None, task_id=None):
self.image_url = image_url # type: str
self.results = results # type: list[RecognizeQrCodeResponseBodyDataElementsResults]
self.task_id = task_id # type: str
def validate(self):
if self.results:
for k in self.results:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeQrCodeResponseBodyDataElements, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
result['Results'] = []
if self.results is not None:
for k in self.results:
result['Results'].append(k.to_map() if k else None)
if self.task_id is not None:
result['TaskId'] = self.task_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
self.results = []
if m.get('Results') is not None:
for k in m.get('Results'):
temp_model = RecognizeQrCodeResponseBodyDataElementsResults()
self.results.append(temp_model.from_map(k))
if m.get('TaskId') is not None:
self.task_id = m.get('TaskId')
return self
class RecognizeQrCodeResponseBodyData(TeaModel):
def __init__(self, elements=None):
self.elements = elements # type: list[RecognizeQrCodeResponseBodyDataElements]
def validate(self):
if self.elements:
for k in self.elements:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeQrCodeResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
result['Elements'] = []
if self.elements is not None:
for k in self.elements:
result['Elements'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.elements = []
if m.get('Elements') is not None:
for k in m.get('Elements'):
temp_model = RecognizeQrCodeResponseBodyDataElements()
self.elements.append(temp_model.from_map(k))
return self
class RecognizeQrCodeResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeQrCodeResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeQrCodeResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeQrCodeResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeQrCodeResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeQrCodeResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeQrCodeResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeQrCodeResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeQuotaInvoiceRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeQuotaInvoiceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeQuotaInvoiceAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeQuotaInvoiceAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeQuotaInvoiceResponseBodyDataContent(TeaModel):
def __init__(self, invoice_amount=None, invoice_code=None, invoice_details=None, invoice_no=None,
sum_amount=None):
self.invoice_amount = invoice_amount # type: str
self.invoice_code = invoice_code # type: str
self.invoice_details = invoice_details # type: str
self.invoice_no = invoice_no # type: str
self.sum_amount = sum_amount # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeQuotaInvoiceResponseBodyDataContent, self).to_map()
if _map is not None:
return _map
result = dict()
if self.invoice_amount is not None:
result['InvoiceAmount'] = self.invoice_amount
if self.invoice_code is not None:
result['InvoiceCode'] = self.invoice_code
if self.invoice_details is not None:
result['InvoiceDetails'] = self.invoice_details
if self.invoice_no is not None:
result['InvoiceNo'] = self.invoice_no
if self.sum_amount is not None:
result['SumAmount'] = self.sum_amount
return result
def from_map(self, m=None):
m = m or dict()
if m.get('InvoiceAmount') is not None:
self.invoice_amount = m.get('InvoiceAmount')
if m.get('InvoiceCode') is not None:
self.invoice_code = m.get('InvoiceCode')
if m.get('InvoiceDetails') is not None:
self.invoice_details = m.get('InvoiceDetails')
if m.get('InvoiceNo') is not None:
self.invoice_no = m.get('InvoiceNo')
if m.get('SumAmount') is not None:
self.sum_amount = m.get('SumAmount')
return self
class RecognizeQuotaInvoiceResponseBodyDataKeyValueInfosValuePositions(TeaModel):
def __init__(self, x=None, y=None):
self.x = x # type: long
self.y = y # type: long
def validate(self):
pass
def to_map(self):
_map = super(RecognizeQuotaInvoiceResponseBodyDataKeyValueInfosValuePositions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizeQuotaInvoiceResponseBodyDataKeyValueInfos(TeaModel):
def __init__(self, key=None, value=None, value_positions=None, value_score=None):
self.key = key # type: str
self.value = value # type: str
self.value_positions = value_positions # type: list[RecognizeQuotaInvoiceResponseBodyDataKeyValueInfosValuePositions]
self.value_score = value_score # type: float
def validate(self):
if self.value_positions:
for k in self.value_positions:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeQuotaInvoiceResponseBodyDataKeyValueInfos, self).to_map()
if _map is not None:
return _map
result = dict()
if self.key is not None:
result['Key'] = self.key
if self.value is not None:
result['Value'] = self.value
result['ValuePositions'] = []
if self.value_positions is not None:
for k in self.value_positions:
result['ValuePositions'].append(k.to_map() if k else None)
if self.value_score is not None:
result['ValueScore'] = self.value_score
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Key') is not None:
self.key = m.get('Key')
if m.get('Value') is not None:
self.value = m.get('Value')
self.value_positions = []
if m.get('ValuePositions') is not None:
for k in m.get('ValuePositions'):
temp_model = RecognizeQuotaInvoiceResponseBodyDataKeyValueInfosValuePositions()
self.value_positions.append(temp_model.from_map(k))
if m.get('ValueScore') is not None:
self.value_score = m.get('ValueScore')
return self
class RecognizeQuotaInvoiceResponseBodyData(TeaModel):
def __init__(self, angle=None, content=None, height=None, key_value_infos=None, org_height=None, org_width=None,
width=None):
self.angle = angle # type: long
self.content = content # type: RecognizeQuotaInvoiceResponseBodyDataContent
self.height = height # type: long
self.key_value_infos = key_value_infos # type: list[RecognizeQuotaInvoiceResponseBodyDataKeyValueInfos]
self.org_height = org_height # type: long
self.org_width = org_width # type: long
self.width = width # type: long
def validate(self):
if self.content:
self.content.validate()
if self.key_value_infos:
for k in self.key_value_infos:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeQuotaInvoiceResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.angle is not None:
result['Angle'] = self.angle
if self.content is not None:
result['Content'] = self.content.to_map()
if self.height is not None:
result['Height'] = self.height
result['KeyValueInfos'] = []
if self.key_value_infos is not None:
for k in self.key_value_infos:
result['KeyValueInfos'].append(k.to_map() if k else None)
if self.org_height is not None:
result['OrgHeight'] = self.org_height
if self.org_width is not None:
result['OrgWidth'] = self.org_width
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Angle') is not None:
self.angle = m.get('Angle')
if m.get('Content') is not None:
temp_model = RecognizeQuotaInvoiceResponseBodyDataContent()
self.content = temp_model.from_map(m['Content'])
if m.get('Height') is not None:
self.height = m.get('Height')
self.key_value_infos = []
if m.get('KeyValueInfos') is not None:
for k in m.get('KeyValueInfos'):
temp_model = RecognizeQuotaInvoiceResponseBodyDataKeyValueInfos()
self.key_value_infos.append(temp_model.from_map(k))
if m.get('OrgHeight') is not None:
self.org_height = m.get('OrgHeight')
if m.get('OrgWidth') is not None:
self.org_width = m.get('OrgWidth')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeQuotaInvoiceResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeQuotaInvoiceResponseBodyData
# Id of the request
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeQuotaInvoiceResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeQuotaInvoiceResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeQuotaInvoiceResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeQuotaInvoiceResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeQuotaInvoiceResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeQuotaInvoiceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeStampRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeStampRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeStampAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeStampAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeStampResponseBodyDataResultsGeneralText(TeaModel):
def __init__(self, confidence=None, content=None):
self.confidence = confidence # type: float
self.content = content # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeStampResponseBodyDataResultsGeneralText, self).to_map()
if _map is not None:
return _map
result = dict()
if self.confidence is not None:
result['Confidence'] = self.confidence
if self.content is not None:
result['Content'] = self.content
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Confidence') is not None:
self.confidence = m.get('Confidence')
if m.get('Content') is not None:
self.content = m.get('Content')
return self
class RecognizeStampResponseBodyDataResultsRoi(TeaModel):
def __init__(self, height=None, left=None, top=None, width=None):
self.height = height # type: int
self.left = left # type: int
self.top = top # type: int
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeStampResponseBodyDataResultsRoi, self).to_map()
if _map is not None:
return _map
result = dict()
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeStampResponseBodyDataResultsText(TeaModel):
def __init__(self, confidence=None, content=None):
self.confidence = confidence # type: float
self.content = content # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeStampResponseBodyDataResultsText, self).to_map()
if _map is not None:
return _map
result = dict()
if self.confidence is not None:
result['Confidence'] = self.confidence
if self.content is not None:
result['Content'] = self.content
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Confidence') is not None:
self.confidence = m.get('Confidence')
if m.get('Content') is not None:
self.content = m.get('Content')
return self
class RecognizeStampResponseBodyDataResults(TeaModel):
def __init__(self, general_text=None, roi=None, text=None):
self.general_text = general_text # type: list[RecognizeStampResponseBodyDataResultsGeneralText]
self.roi = roi # type: RecognizeStampResponseBodyDataResultsRoi
self.text = text # type: RecognizeStampResponseBodyDataResultsText
def validate(self):
if self.general_text:
for k in self.general_text:
if k:
k.validate()
if self.roi:
self.roi.validate()
if self.text:
self.text.validate()
def to_map(self):
_map = super(RecognizeStampResponseBodyDataResults, self).to_map()
if _map is not None:
return _map
result = dict()
result['GeneralText'] = []
if self.general_text is not None:
for k in self.general_text:
result['GeneralText'].append(k.to_map() if k else None)
if self.roi is not None:
result['Roi'] = self.roi.to_map()
if self.text is not None:
result['Text'] = self.text.to_map()
return result
def from_map(self, m=None):
m = m or dict()
self.general_text = []
if m.get('GeneralText') is not None:
for k in m.get('GeneralText'):
temp_model = RecognizeStampResponseBodyDataResultsGeneralText()
self.general_text.append(temp_model.from_map(k))
if m.get('Roi') is not None:
temp_model = RecognizeStampResponseBodyDataResultsRoi()
self.roi = temp_model.from_map(m['Roi'])
if m.get('Text') is not None:
temp_model = RecognizeStampResponseBodyDataResultsText()
self.text = temp_model.from_map(m['Text'])
return self
class RecognizeStampResponseBodyData(TeaModel):
def __init__(self, results=None):
self.results = results # type: list[RecognizeStampResponseBodyDataResults]
def validate(self):
if self.results:
for k in self.results:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeStampResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
result['Results'] = []
if self.results is not None:
for k in self.results:
result['Results'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.results = []
if m.get('Results') is not None:
for k in m.get('Results'):
temp_model = RecognizeStampResponseBodyDataResults()
self.results.append(temp_model.from_map(k))
return self
class RecognizeStampResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeStampResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeStampResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeStampResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeStampResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeStampResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeStampResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeStampResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeTableRequest(TeaModel):
def __init__(self, assure_direction=None, has_line=None, image_url=None, output_format=None,
skip_detection=None, use_finance_model=None):
self.assure_direction = assure_direction # type: bool
self.has_line = has_line # type: bool
self.image_url = image_url # type: str
self.output_format = output_format # type: str
self.skip_detection = skip_detection # type: bool
self.use_finance_model = use_finance_model # type: bool
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTableRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.assure_direction is not None:
result['AssureDirection'] = self.assure_direction
if self.has_line is not None:
result['HasLine'] = self.has_line
if self.image_url is not None:
result['ImageURL'] = self.image_url
if self.output_format is not None:
result['OutputFormat'] = self.output_format
if self.skip_detection is not None:
result['SkipDetection'] = self.skip_detection
if self.use_finance_model is not None:
result['UseFinanceModel'] = self.use_finance_model
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AssureDirection') is not None:
self.assure_direction = m.get('AssureDirection')
if m.get('HasLine') is not None:
self.has_line = m.get('HasLine')
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
if m.get('OutputFormat') is not None:
self.output_format = m.get('OutputFormat')
if m.get('SkipDetection') is not None:
self.skip_detection = m.get('SkipDetection')
if m.get('UseFinanceModel') is not None:
self.use_finance_model = m.get('UseFinanceModel')
return self
class RecognizeTableAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None, assure_direction=None, has_line=None, output_format=None,
skip_detection=None, use_finance_model=None):
self.image_urlobject = image_urlobject # type: READABLE
self.assure_direction = assure_direction # type: bool
self.has_line = has_line # type: bool
self.output_format = output_format # type: str
self.skip_detection = skip_detection # type: bool
self.use_finance_model = use_finance_model # type: bool
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeTableAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
if self.assure_direction is not None:
result['AssureDirection'] = self.assure_direction
if self.has_line is not None:
result['HasLine'] = self.has_line
if self.output_format is not None:
result['OutputFormat'] = self.output_format
if self.skip_detection is not None:
result['SkipDetection'] = self.skip_detection
if self.use_finance_model is not None:
result['UseFinanceModel'] = self.use_finance_model
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
if m.get('AssureDirection') is not None:
self.assure_direction = m.get('AssureDirection')
if m.get('HasLine') is not None:
self.has_line = m.get('HasLine')
if m.get('OutputFormat') is not None:
self.output_format = m.get('OutputFormat')
if m.get('SkipDetection') is not None:
self.skip_detection = m.get('SkipDetection')
if m.get('UseFinanceModel') is not None:
self.use_finance_model = m.get('UseFinanceModel')
return self
class RecognizeTableResponseBodyDataTablesTableRowsTableColumns(TeaModel):
def __init__(self, end_column=None, end_row=None, height=None, start_column=None, start_row=None, texts=None,
width=None):
self.end_column = end_column # type: int
self.end_row = end_row # type: int
self.height = height # type: int
self.start_column = start_column # type: int
self.start_row = start_row # type: int
self.texts = texts # type: list[str]
self.width = width # type: int
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTableResponseBodyDataTablesTableRowsTableColumns, self).to_map()
if _map is not None:
return _map
result = dict()
if self.end_column is not None:
result['EndColumn'] = self.end_column
if self.end_row is not None:
result['EndRow'] = self.end_row
if self.height is not None:
result['Height'] = self.height
if self.start_column is not None:
result['StartColumn'] = self.start_column
if self.start_row is not None:
result['StartRow'] = self.start_row
if self.texts is not None:
result['Texts'] = self.texts
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('EndColumn') is not None:
self.end_column = m.get('EndColumn')
if m.get('EndRow') is not None:
self.end_row = m.get('EndRow')
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('StartColumn') is not None:
self.start_column = m.get('StartColumn')
if m.get('StartRow') is not None:
self.start_row = m.get('StartRow')
if m.get('Texts') is not None:
self.texts = m.get('Texts')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeTableResponseBodyDataTablesTableRows(TeaModel):
def __init__(self, table_columns=None):
self.table_columns = table_columns # type: list[RecognizeTableResponseBodyDataTablesTableRowsTableColumns]
def validate(self):
if self.table_columns:
for k in self.table_columns:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeTableResponseBodyDataTablesTableRows, self).to_map()
if _map is not None:
return _map
result = dict()
result['TableColumns'] = []
if self.table_columns is not None:
for k in self.table_columns:
result['TableColumns'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.table_columns = []
if m.get('TableColumns') is not None:
for k in m.get('TableColumns'):
temp_model = RecognizeTableResponseBodyDataTablesTableRowsTableColumns()
self.table_columns.append(temp_model.from_map(k))
return self
class RecognizeTableResponseBodyDataTables(TeaModel):
def __init__(self, head=None, table_rows=None, tail=None):
self.head = head # type: list[str]
self.table_rows = table_rows # type: list[RecognizeTableResponseBodyDataTablesTableRows]
self.tail = tail # type: list[str]
def validate(self):
if self.table_rows:
for k in self.table_rows:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeTableResponseBodyDataTables, self).to_map()
if _map is not None:
return _map
result = dict()
if self.head is not None:
result['Head'] = self.head
result['TableRows'] = []
if self.table_rows is not None:
for k in self.table_rows:
result['TableRows'].append(k.to_map() if k else None)
if self.tail is not None:
result['Tail'] = self.tail
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Head') is not None:
self.head = m.get('Head')
self.table_rows = []
if m.get('TableRows') is not None:
for k in m.get('TableRows'):
temp_model = RecognizeTableResponseBodyDataTablesTableRows()
self.table_rows.append(temp_model.from_map(k))
if m.get('Tail') is not None:
self.tail = m.get('Tail')
return self
class RecognizeTableResponseBodyData(TeaModel):
def __init__(self, file_content=None, tables=None):
self.file_content = file_content # type: str
self.tables = tables # type: list[RecognizeTableResponseBodyDataTables]
def validate(self):
if self.tables:
for k in self.tables:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeTableResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.file_content is not None:
result['FileContent'] = self.file_content
result['Tables'] = []
if self.tables is not None:
for k in self.tables:
result['Tables'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
if m.get('FileContent') is not None:
self.file_content = m.get('FileContent')
self.tables = []
if m.get('Tables') is not None:
for k in m.get('Tables'):
temp_model = RecognizeTableResponseBodyDataTables()
self.tables.append(temp_model.from_map(k))
return self
class RecognizeTableResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeTableResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeTableResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeTableResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeTableResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeTableResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeTableResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeTableResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeTakeoutOrderRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTakeoutOrderRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeTakeoutOrderAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeTakeoutOrderAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeTakeoutOrderResponseBodyDataElements(TeaModel):
def __init__(self, boxes=None, name=None, score=None, value=None):
self.boxes = boxes # type: list[int]
self.name = name # type: str
self.score = score # type: float
self.value = value # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTakeoutOrderResponseBodyDataElements, self).to_map()
if _map is not None:
return _map
result = dict()
if self.boxes is not None:
result['Boxes'] = self.boxes
if self.name is not None:
result['Name'] = self.name
if self.score is not None:
result['Score'] = self.score
if self.value is not None:
result['Value'] = self.value
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Boxes') is not None:
self.boxes = m.get('Boxes')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Score') is not None:
self.score = m.get('Score')
if m.get('Value') is not None:
self.value = m.get('Value')
return self
class RecognizeTakeoutOrderResponseBodyData(TeaModel):
def __init__(self, elements=None):
self.elements = elements # type: list[RecognizeTakeoutOrderResponseBodyDataElements]
def validate(self):
if self.elements:
for k in self.elements:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeTakeoutOrderResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
result['Elements'] = []
if self.elements is not None:
for k in self.elements:
result['Elements'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.elements = []
if m.get('Elements') is not None:
for k in m.get('Elements'):
temp_model = RecognizeTakeoutOrderResponseBodyDataElements()
self.elements.append(temp_model.from_map(k))
return self
class RecognizeTakeoutOrderResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeTakeoutOrderResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeTakeoutOrderResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeTakeoutOrderResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeTakeoutOrderResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeTakeoutOrderResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeTakeoutOrderResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeTakeoutOrderResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeTaxiInvoiceRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTaxiInvoiceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeTaxiInvoiceAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeTaxiInvoiceAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeTaxiInvoiceResponseBodyDataInvoicesInvoiceRoi(TeaModel):
def __init__(self, h=None, w=None, x=None, y=None):
self.h = h # type: float
self.w = w # type: float
self.x = x # type: float
self.y = y # type: float
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTaxiInvoiceResponseBodyDataInvoicesInvoiceRoi, self).to_map()
if _map is not None:
return _map
result = dict()
if self.h is not None:
result['H'] = self.h
if self.w is not None:
result['W'] = self.w
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('H') is not None:
self.h = m.get('H')
if m.get('W') is not None:
self.w = m.get('W')
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoiCenter(TeaModel):
def __init__(self, x=None, y=None):
self.x = x # type: float
self.y = y # type: float
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoiCenter, self).to_map()
if _map is not None:
return _map
result = dict()
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoiSize(TeaModel):
def __init__(self, h=None, w=None):
self.h = h # type: float
self.w = w # type: float
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoiSize, self).to_map()
if _map is not None:
return _map
result = dict()
if self.h is not None:
result['H'] = self.h
if self.w is not None:
result['W'] = self.w
return result
def from_map(self, m=None):
m = m or dict()
if m.get('H') is not None:
self.h = m.get('H')
if m.get('W') is not None:
self.w = m.get('W')
return self
class RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoi(TeaModel):
def __init__(self, angle=None, center=None, size=None):
self.angle = angle # type: float
self.center = center # type: RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoiCenter
self.size = size # type: RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoiSize
def validate(self):
if self.center:
self.center.validate()
if self.size:
self.size.validate()
def to_map(self):
_map = super(RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoi, self).to_map()
if _map is not None:
return _map
result = dict()
if self.angle is not None:
result['Angle'] = self.angle
if self.center is not None:
result['Center'] = self.center.to_map()
if self.size is not None:
result['Size'] = self.size.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Angle') is not None:
self.angle = m.get('Angle')
if m.get('Center') is not None:
temp_model = RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoiCenter()
self.center = temp_model.from_map(m['Center'])
if m.get('Size') is not None:
temp_model = RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoiSize()
self.size = temp_model.from_map(m['Size'])
return self
class RecognizeTaxiInvoiceResponseBodyDataInvoicesItems(TeaModel):
def __init__(self, item_roi=None, text=None):
self.item_roi = item_roi # type: RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoi
self.text = text # type: str
def validate(self):
if self.item_roi:
self.item_roi.validate()
def to_map(self):
_map = super(RecognizeTaxiInvoiceResponseBodyDataInvoicesItems, self).to_map()
if _map is not None:
return _map
result = dict()
if self.item_roi is not None:
result['ItemRoi'] = self.item_roi.to_map()
if self.text is not None:
result['Text'] = self.text
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ItemRoi') is not None:
temp_model = RecognizeTaxiInvoiceResponseBodyDataInvoicesItemsItemRoi()
self.item_roi = temp_model.from_map(m['ItemRoi'])
if m.get('Text') is not None:
self.text = m.get('Text')
return self
class RecognizeTaxiInvoiceResponseBodyDataInvoices(TeaModel):
def __init__(self, invoice_roi=None, items=None, rotate_type=None):
self.invoice_roi = invoice_roi # type: RecognizeTaxiInvoiceResponseBodyDataInvoicesInvoiceRoi
self.items = items # type: list[RecognizeTaxiInvoiceResponseBodyDataInvoicesItems]
self.rotate_type = rotate_type # type: int
def validate(self):
if self.invoice_roi:
self.invoice_roi.validate()
if self.items:
for k in self.items:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeTaxiInvoiceResponseBodyDataInvoices, self).to_map()
if _map is not None:
return _map
result = dict()
if self.invoice_roi is not None:
result['InvoiceRoi'] = self.invoice_roi.to_map()
result['Items'] = []
if self.items is not None:
for k in self.items:
result['Items'].append(k.to_map() if k else None)
if self.rotate_type is not None:
result['RotateType'] = self.rotate_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('InvoiceRoi') is not None:
temp_model = RecognizeTaxiInvoiceResponseBodyDataInvoicesInvoiceRoi()
self.invoice_roi = temp_model.from_map(m['InvoiceRoi'])
self.items = []
if m.get('Items') is not None:
for k in m.get('Items'):
temp_model = RecognizeTaxiInvoiceResponseBodyDataInvoicesItems()
self.items.append(temp_model.from_map(k))
if m.get('RotateType') is not None:
self.rotate_type = m.get('RotateType')
return self
class RecognizeTaxiInvoiceResponseBodyData(TeaModel):
def __init__(self, invoices=None):
self.invoices = invoices # type: list[RecognizeTaxiInvoiceResponseBodyDataInvoices]
def validate(self):
if self.invoices:
for k in self.invoices:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeTaxiInvoiceResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
result['Invoices'] = []
if self.invoices is not None:
for k in self.invoices:
result['Invoices'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
self.invoices = []
if m.get('Invoices') is not None:
for k in m.get('Invoices'):
temp_model = RecognizeTaxiInvoiceResponseBodyDataInvoices()
self.invoices.append(temp_model.from_map(k))
return self
class RecognizeTaxiInvoiceResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeTaxiInvoiceResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeTaxiInvoiceResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeTaxiInvoiceResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeTaxiInvoiceResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeTaxiInvoiceResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeTaxiInvoiceResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeTaxiInvoiceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeTicketInvoiceRequest(TeaModel):
def __init__(self, image_url=None):
# A short description of struct
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTicketInvoiceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeTicketInvoiceAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeTicketInvoiceAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeTicketInvoiceResponseBodyDataResultsContent(TeaModel):
def __init__(self, anti_fake_code=None, invoice_code=None, invoice_date=None, invoice_number=None,
payee_name=None, payee_register_no=None, payer_name=None, payer_register_no=None, sum_amount=None):
self.anti_fake_code = anti_fake_code # type: str
self.invoice_code = invoice_code # type: str
self.invoice_date = invoice_date # type: str
self.invoice_number = invoice_number # type: str
self.payee_name = payee_name # type: str
self.payee_register_no = payee_register_no # type: str
self.payer_name = payer_name # type: str
self.payer_register_no = payer_register_no # type: str
self.sum_amount = sum_amount # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTicketInvoiceResponseBodyDataResultsContent, self).to_map()
if _map is not None:
return _map
result = dict()
if self.anti_fake_code is not None:
result['AntiFakeCode'] = self.anti_fake_code
if self.invoice_code is not None:
result['InvoiceCode'] = self.invoice_code
if self.invoice_date is not None:
result['InvoiceDate'] = self.invoice_date
if self.invoice_number is not None:
result['InvoiceNumber'] = self.invoice_number
if self.payee_name is not None:
result['PayeeName'] = self.payee_name
if self.payee_register_no is not None:
result['PayeeRegisterNo'] = self.payee_register_no
if self.payer_name is not None:
result['PayerName'] = self.payer_name
if self.payer_register_no is not None:
result['PayerRegisterNo'] = self.payer_register_no
if self.sum_amount is not None:
result['SumAmount'] = self.sum_amount
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AntiFakeCode') is not None:
self.anti_fake_code = m.get('AntiFakeCode')
if m.get('InvoiceCode') is not None:
self.invoice_code = m.get('InvoiceCode')
if m.get('InvoiceDate') is not None:
self.invoice_date = m.get('InvoiceDate')
if m.get('InvoiceNumber') is not None:
self.invoice_number = m.get('InvoiceNumber')
if m.get('PayeeName') is not None:
self.payee_name = m.get('PayeeName')
if m.get('PayeeRegisterNo') is not None:
self.payee_register_no = m.get('PayeeRegisterNo')
if m.get('PayerName') is not None:
self.payer_name = m.get('PayerName')
if m.get('PayerRegisterNo') is not None:
self.payer_register_no = m.get('PayerRegisterNo')
if m.get('SumAmount') is not None:
self.sum_amount = m.get('SumAmount')
return self
class RecognizeTicketInvoiceResponseBodyDataResultsKeyValueInfosValuePositions(TeaModel):
def __init__(self, x=None, y=None):
self.x = x # type: long
self.y = y # type: long
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTicketInvoiceResponseBodyDataResultsKeyValueInfosValuePositions, self).to_map()
if _map is not None:
return _map
result = dict()
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizeTicketInvoiceResponseBodyDataResultsKeyValueInfos(TeaModel):
def __init__(self, key=None, value=None, value_positions=None, value_score=None):
self.key = key # type: str
self.value = value # type: str
self.value_positions = value_positions # type: list[RecognizeTicketInvoiceResponseBodyDataResultsKeyValueInfosValuePositions]
self.value_score = value_score # type: float
def validate(self):
if self.value_positions:
for k in self.value_positions:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeTicketInvoiceResponseBodyDataResultsKeyValueInfos, self).to_map()
if _map is not None:
return _map
result = dict()
if self.key is not None:
result['Key'] = self.key
if self.value is not None:
result['Value'] = self.value
result['ValuePositions'] = []
if self.value_positions is not None:
for k in self.value_positions:
result['ValuePositions'].append(k.to_map() if k else None)
if self.value_score is not None:
result['ValueScore'] = self.value_score
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Key') is not None:
self.key = m.get('Key')
if m.get('Value') is not None:
self.value = m.get('Value')
self.value_positions = []
if m.get('ValuePositions') is not None:
for k in m.get('ValuePositions'):
temp_model = RecognizeTicketInvoiceResponseBodyDataResultsKeyValueInfosValuePositions()
self.value_positions.append(temp_model.from_map(k))
if m.get('ValueScore') is not None:
self.value_score = m.get('ValueScore')
return self
class RecognizeTicketInvoiceResponseBodyDataResultsSliceRectangle(TeaModel):
def __init__(self, x=None, y=None):
self.x = x # type: long
self.y = y # type: long
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTicketInvoiceResponseBodyDataResultsSliceRectangle, self).to_map()
if _map is not None:
return _map
result = dict()
if self.x is not None:
result['X'] = self.x
if self.y is not None:
result['Y'] = self.y
return result
def from_map(self, m=None):
m = m or dict()
if m.get('X') is not None:
self.x = m.get('X')
if m.get('Y') is not None:
self.y = m.get('Y')
return self
class RecognizeTicketInvoiceResponseBodyDataResults(TeaModel):
def __init__(self, content=None, index=None, key_value_infos=None, slice_rectangle=None, type=None):
self.content = content # type: RecognizeTicketInvoiceResponseBodyDataResultsContent
self.index = index # type: long
self.key_value_infos = key_value_infos # type: list[RecognizeTicketInvoiceResponseBodyDataResultsKeyValueInfos]
self.slice_rectangle = slice_rectangle # type: list[RecognizeTicketInvoiceResponseBodyDataResultsSliceRectangle]
self.type = type # type: str
def validate(self):
if self.content:
self.content.validate()
if self.key_value_infos:
for k in self.key_value_infos:
if k:
k.validate()
if self.slice_rectangle:
for k in self.slice_rectangle:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeTicketInvoiceResponseBodyDataResults, self).to_map()
if _map is not None:
return _map
result = dict()
if self.content is not None:
result['Content'] = self.content.to_map()
if self.index is not None:
result['Index'] = self.index
result['KeyValueInfos'] = []
if self.key_value_infos is not None:
for k in self.key_value_infos:
result['KeyValueInfos'].append(k.to_map() if k else None)
result['SliceRectangle'] = []
if self.slice_rectangle is not None:
for k in self.slice_rectangle:
result['SliceRectangle'].append(k.to_map() if k else None)
if self.type is not None:
result['Type'] = self.type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Content') is not None:
temp_model = RecognizeTicketInvoiceResponseBodyDataResultsContent()
self.content = temp_model.from_map(m['Content'])
if m.get('Index') is not None:
self.index = m.get('Index')
self.key_value_infos = []
if m.get('KeyValueInfos') is not None:
for k in m.get('KeyValueInfos'):
temp_model = RecognizeTicketInvoiceResponseBodyDataResultsKeyValueInfos()
self.key_value_infos.append(temp_model.from_map(k))
self.slice_rectangle = []
if m.get('SliceRectangle') is not None:
for k in m.get('SliceRectangle'):
temp_model = RecognizeTicketInvoiceResponseBodyDataResultsSliceRectangle()
self.slice_rectangle.append(temp_model.from_map(k))
if m.get('Type') is not None:
self.type = m.get('Type')
return self
class RecognizeTicketInvoiceResponseBodyData(TeaModel):
def __init__(self, count=None, height=None, org_height=None, org_width=None, results=None, width=None):
self.count = count # type: long
self.height = height # type: long
self.org_height = org_height # type: long
self.org_width = org_width # type: long
self.results = results # type: list[RecognizeTicketInvoiceResponseBodyDataResults]
self.width = width # type: long
def validate(self):
if self.results:
for k in self.results:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeTicketInvoiceResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.count is not None:
result['Count'] = self.count
if self.height is not None:
result['Height'] = self.height
if self.org_height is not None:
result['OrgHeight'] = self.org_height
if self.org_width is not None:
result['OrgWidth'] = self.org_width
result['Results'] = []
if self.results is not None:
for k in self.results:
result['Results'].append(k.to_map() if k else None)
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Count') is not None:
self.count = m.get('Count')
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('OrgHeight') is not None:
self.org_height = m.get('OrgHeight')
if m.get('OrgWidth') is not None:
self.org_width = m.get('OrgWidth')
self.results = []
if m.get('Results') is not None:
for k in m.get('Results'):
temp_model = RecognizeTicketInvoiceResponseBodyDataResults()
self.results.append(temp_model.from_map(k))
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeTicketInvoiceResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeTicketInvoiceResponseBodyData
# Id of the request
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeTicketInvoiceResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeTicketInvoiceResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeTicketInvoiceResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeTicketInvoiceResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeTicketInvoiceResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeTicketInvoiceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeTrainTicketRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTrainTicketRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeTrainTicketAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeTrainTicketAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeTrainTicketResponseBodyData(TeaModel):
def __init__(self, date=None, departure_station=None, destination=None, level=None, name=None, number=None,
price=None, seat=None):
self.date = date # type: str
self.departure_station = departure_station # type: str
self.destination = destination # type: str
self.level = level # type: str
self.name = name # type: str
self.number = number # type: str
self.price = price # type: float
self.seat = seat # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeTrainTicketResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.date is not None:
result['Date'] = self.date
if self.departure_station is not None:
result['DepartureStation'] = self.departure_station
if self.destination is not None:
result['Destination'] = self.destination
if self.level is not None:
result['Level'] = self.level
if self.name is not None:
result['Name'] = self.name
if self.number is not None:
result['Number'] = self.number
if self.price is not None:
result['Price'] = self.price
if self.seat is not None:
result['Seat'] = self.seat
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Date') is not None:
self.date = m.get('Date')
if m.get('DepartureStation') is not None:
self.departure_station = m.get('DepartureStation')
if m.get('Destination') is not None:
self.destination = m.get('Destination')
if m.get('Level') is not None:
self.level = m.get('Level')
if m.get('Name') is not None:
self.name = m.get('Name')
if m.get('Number') is not None:
self.number = m.get('Number')
if m.get('Price') is not None:
self.price = m.get('Price')
if m.get('Seat') is not None:
self.seat = m.get('Seat')
return self
class RecognizeTrainTicketResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeTrainTicketResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeTrainTicketResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeTrainTicketResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeTrainTicketResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeTrainTicketResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeTrainTicketResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeTrainTicketResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeVATInvoiceRequest(TeaModel):
def __init__(self, file_type=None, file_url=None):
self.file_type = file_type # type: str
self.file_url = file_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeVATInvoiceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.file_type is not None:
result['FileType'] = self.file_type
if self.file_url is not None:
result['FileURL'] = self.file_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('FileType') is not None:
self.file_type = m.get('FileType')
if m.get('FileURL') is not None:
self.file_url = m.get('FileURL')
return self
class RecognizeVATInvoiceAdvanceRequest(TeaModel):
def __init__(self, file_urlobject=None, file_type=None):
self.file_urlobject = file_urlobject # type: READABLE
self.file_type = file_type # type: str
def validate(self):
self.validate_required(self.file_urlobject, 'file_urlobject')
def to_map(self):
_map = super(RecognizeVATInvoiceAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.file_urlobject is not None:
result['FileURLObject'] = self.file_urlobject
if self.file_type is not None:
result['FileType'] = self.file_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('FileURLObject') is not None:
self.file_urlobject = m.get('FileURLObject')
if m.get('FileType') is not None:
self.file_type = m.get('FileType')
return self
class RecognizeVATInvoiceResponseBodyDataBox(TeaModel):
def __init__(self, checkers=None, clerks=None, invoice_amounts=None, invoice_codes=None, invoice_dates=None,
invoice_fake_codes=None, invoice_noes=None, payee_addresses=None, payee_bank_names=None, payee_names=None,
payee_register_noes=None, payees=None, payer_addresses=None, payer_bank_names=None, payer_names=None,
payer_register_noes=None, sum_amounts=None, tax_amounts=None, without_tax_amounts=None):
self.checkers = checkers # type: list[float]
self.clerks = clerks # type: list[float]
self.invoice_amounts = invoice_amounts # type: list[float]
self.invoice_codes = invoice_codes # type: list[float]
self.invoice_dates = invoice_dates # type: list[float]
self.invoice_fake_codes = invoice_fake_codes # type: list[float]
self.invoice_noes = invoice_noes # type: list[float]
self.payee_addresses = payee_addresses # type: list[float]
self.payee_bank_names = payee_bank_names # type: list[float]
self.payee_names = payee_names # type: list[float]
self.payee_register_noes = payee_register_noes # type: list[float]
self.payees = payees # type: list[float]
self.payer_addresses = payer_addresses # type: list[float]
self.payer_bank_names = payer_bank_names # type: list[float]
self.payer_names = payer_names # type: list[float]
self.payer_register_noes = payer_register_noes # type: list[float]
self.sum_amounts = sum_amounts # type: list[float]
self.tax_amounts = tax_amounts # type: list[float]
self.without_tax_amounts = without_tax_amounts # type: list[float]
def validate(self):
pass
def to_map(self):
_map = super(RecognizeVATInvoiceResponseBodyDataBox, self).to_map()
if _map is not None:
return _map
result = dict()
if self.checkers is not None:
result['Checkers'] = self.checkers
if self.clerks is not None:
result['Clerks'] = self.clerks
if self.invoice_amounts is not None:
result['InvoiceAmounts'] = self.invoice_amounts
if self.invoice_codes is not None:
result['InvoiceCodes'] = self.invoice_codes
if self.invoice_dates is not None:
result['InvoiceDates'] = self.invoice_dates
if self.invoice_fake_codes is not None:
result['InvoiceFakeCodes'] = self.invoice_fake_codes
if self.invoice_noes is not None:
result['InvoiceNoes'] = self.invoice_noes
if self.payee_addresses is not None:
result['PayeeAddresses'] = self.payee_addresses
if self.payee_bank_names is not None:
result['PayeeBankNames'] = self.payee_bank_names
if self.payee_names is not None:
result['PayeeNames'] = self.payee_names
if self.payee_register_noes is not None:
result['PayeeRegisterNoes'] = self.payee_register_noes
if self.payees is not None:
result['Payees'] = self.payees
if self.payer_addresses is not None:
result['PayerAddresses'] = self.payer_addresses
if self.payer_bank_names is not None:
result['PayerBankNames'] = self.payer_bank_names
if self.payer_names is not None:
result['PayerNames'] = self.payer_names
if self.payer_register_noes is not None:
result['PayerRegisterNoes'] = self.payer_register_noes
if self.sum_amounts is not None:
result['SumAmounts'] = self.sum_amounts
if self.tax_amounts is not None:
result['TaxAmounts'] = self.tax_amounts
if self.without_tax_amounts is not None:
result['WithoutTaxAmounts'] = self.without_tax_amounts
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Checkers') is not None:
self.checkers = m.get('Checkers')
if m.get('Clerks') is not None:
self.clerks = m.get('Clerks')
if m.get('InvoiceAmounts') is not None:
self.invoice_amounts = m.get('InvoiceAmounts')
if m.get('InvoiceCodes') is not None:
self.invoice_codes = m.get('InvoiceCodes')
if m.get('InvoiceDates') is not None:
self.invoice_dates = m.get('InvoiceDates')
if m.get('InvoiceFakeCodes') is not None:
self.invoice_fake_codes = m.get('InvoiceFakeCodes')
if m.get('InvoiceNoes') is not None:
self.invoice_noes = m.get('InvoiceNoes')
if m.get('PayeeAddresses') is not None:
self.payee_addresses = m.get('PayeeAddresses')
if m.get('PayeeBankNames') is not None:
self.payee_bank_names = m.get('PayeeBankNames')
if m.get('PayeeNames') is not None:
self.payee_names = m.get('PayeeNames')
if m.get('PayeeRegisterNoes') is not None:
self.payee_register_noes = m.get('PayeeRegisterNoes')
if m.get('Payees') is not None:
self.payees = m.get('Payees')
if m.get('PayerAddresses') is not None:
self.payer_addresses = m.get('PayerAddresses')
if m.get('PayerBankNames') is not None:
self.payer_bank_names = m.get('PayerBankNames')
if m.get('PayerNames') is not None:
self.payer_names = m.get('PayerNames')
if m.get('PayerRegisterNoes') is not None:
self.payer_register_noes = m.get('PayerRegisterNoes')
if m.get('SumAmounts') is not None:
self.sum_amounts = m.get('SumAmounts')
if m.get('TaxAmounts') is not None:
self.tax_amounts = m.get('TaxAmounts')
if m.get('WithoutTaxAmounts') is not None:
self.without_tax_amounts = m.get('WithoutTaxAmounts')
return self
class RecognizeVATInvoiceResponseBodyDataContent(TeaModel):
def __init__(self, anti_fake_code=None, checker=None, clerk=None, invoice_amount=None, invoice_code=None,
invoice_date=None, invoice_no=None, payee=None, payee_address=None, payee_bank_name=None, payee_name=None,
payee_register_no=None, payer_address=None, payer_bank_name=None, payer_name=None, payer_register_no=None,
sum_amount=None, tax_amount=None, without_tax_amount=None):
self.anti_fake_code = anti_fake_code # type: str
self.checker = checker # type: str
self.clerk = clerk # type: str
self.invoice_amount = invoice_amount # type: str
self.invoice_code = invoice_code # type: str
self.invoice_date = invoice_date # type: str
self.invoice_no = invoice_no # type: str
self.payee = payee # type: str
self.payee_address = payee_address # type: str
self.payee_bank_name = payee_bank_name # type: str
self.payee_name = payee_name # type: str
self.payee_register_no = payee_register_no # type: str
self.payer_address = payer_address # type: str
self.payer_bank_name = payer_bank_name # type: str
self.payer_name = payer_name # type: str
self.payer_register_no = payer_register_no # type: str
self.sum_amount = sum_amount # type: str
self.tax_amount = tax_amount # type: str
self.without_tax_amount = without_tax_amount # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeVATInvoiceResponseBodyDataContent, self).to_map()
if _map is not None:
return _map
result = dict()
if self.anti_fake_code is not None:
result['AntiFakeCode'] = self.anti_fake_code
if self.checker is not None:
result['Checker'] = self.checker
if self.clerk is not None:
result['Clerk'] = self.clerk
if self.invoice_amount is not None:
result['InvoiceAmount'] = self.invoice_amount
if self.invoice_code is not None:
result['InvoiceCode'] = self.invoice_code
if self.invoice_date is not None:
result['InvoiceDate'] = self.invoice_date
if self.invoice_no is not None:
result['InvoiceNo'] = self.invoice_no
if self.payee is not None:
result['Payee'] = self.payee
if self.payee_address is not None:
result['PayeeAddress'] = self.payee_address
if self.payee_bank_name is not None:
result['PayeeBankName'] = self.payee_bank_name
if self.payee_name is not None:
result['PayeeName'] = self.payee_name
if self.payee_register_no is not None:
result['PayeeRegisterNo'] = self.payee_register_no
if self.payer_address is not None:
result['PayerAddress'] = self.payer_address
if self.payer_bank_name is not None:
result['PayerBankName'] = self.payer_bank_name
if self.payer_name is not None:
result['PayerName'] = self.payer_name
if self.payer_register_no is not None:
result['PayerRegisterNo'] = self.payer_register_no
if self.sum_amount is not None:
result['SumAmount'] = self.sum_amount
if self.tax_amount is not None:
result['TaxAmount'] = self.tax_amount
if self.without_tax_amount is not None:
result['WithoutTaxAmount'] = self.without_tax_amount
return result
def from_map(self, m=None):
m = m or dict()
if m.get('AntiFakeCode') is not None:
self.anti_fake_code = m.get('AntiFakeCode')
if m.get('Checker') is not None:
self.checker = m.get('Checker')
if m.get('Clerk') is not None:
self.clerk = m.get('Clerk')
if m.get('InvoiceAmount') is not None:
self.invoice_amount = m.get('InvoiceAmount')
if m.get('InvoiceCode') is not None:
self.invoice_code = m.get('InvoiceCode')
if m.get('InvoiceDate') is not None:
self.invoice_date = m.get('InvoiceDate')
if m.get('InvoiceNo') is not None:
self.invoice_no = m.get('InvoiceNo')
if m.get('Payee') is not None:
self.payee = m.get('Payee')
if m.get('PayeeAddress') is not None:
self.payee_address = m.get('PayeeAddress')
if m.get('PayeeBankName') is not None:
self.payee_bank_name = m.get('PayeeBankName')
if m.get('PayeeName') is not None:
self.payee_name = m.get('PayeeName')
if m.get('PayeeRegisterNo') is not None:
self.payee_register_no = m.get('PayeeRegisterNo')
if m.get('PayerAddress') is not None:
self.payer_address = m.get('PayerAddress')
if m.get('PayerBankName') is not None:
self.payer_bank_name = m.get('PayerBankName')
if m.get('PayerName') is not None:
self.payer_name = m.get('PayerName')
if m.get('PayerRegisterNo') is not None:
self.payer_register_no = m.get('PayerRegisterNo')
if m.get('SumAmount') is not None:
self.sum_amount = m.get('SumAmount')
if m.get('TaxAmount') is not None:
self.tax_amount = m.get('TaxAmount')
if m.get('WithoutTaxAmount') is not None:
self.without_tax_amount = m.get('WithoutTaxAmount')
return self
class RecognizeVATInvoiceResponseBodyData(TeaModel):
def __init__(self, box=None, content=None):
self.box = box # type: RecognizeVATInvoiceResponseBodyDataBox
self.content = content # type: RecognizeVATInvoiceResponseBodyDataContent
def validate(self):
if self.box:
self.box.validate()
if self.content:
self.content.validate()
def to_map(self):
_map = super(RecognizeVATInvoiceResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.box is not None:
result['Box'] = self.box.to_map()
if self.content is not None:
result['Content'] = self.content.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Box') is not None:
temp_model = RecognizeVATInvoiceResponseBodyDataBox()
self.box = temp_model.from_map(m['Box'])
if m.get('Content') is not None:
temp_model = RecognizeVATInvoiceResponseBodyDataContent()
self.content = temp_model.from_map(m['Content'])
return self
class RecognizeVATInvoiceResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeVATInvoiceResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeVATInvoiceResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeVATInvoiceResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeVATInvoiceResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeVATInvoiceResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeVATInvoiceResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeVATInvoiceResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeVINCodeRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeVINCodeRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeVINCodeAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeVINCodeAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeVINCodeResponseBodyData(TeaModel):
def __init__(self, vin_code=None):
self.vin_code = vin_code # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeVINCodeResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.vin_code is not None:
result['VinCode'] = self.vin_code
return result
def from_map(self, m=None):
m = m or dict()
if m.get('VinCode') is not None:
self.vin_code = m.get('VinCode')
return self
class RecognizeVINCodeResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeVINCodeResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeVINCodeResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeVINCodeResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeVINCodeResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeVINCodeResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeVINCodeResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeVINCodeResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeVerificationcodeRequest(TeaModel):
def __init__(self, image_url=None):
self.image_url = image_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeVerificationcodeRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_url is not None:
result['ImageURL'] = self.image_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURL') is not None:
self.image_url = m.get('ImageURL')
return self
class RecognizeVerificationcodeAdvanceRequest(TeaModel):
def __init__(self, image_urlobject=None):
self.image_urlobject = image_urlobject # type: READABLE
def validate(self):
self.validate_required(self.image_urlobject, 'image_urlobject')
def to_map(self):
_map = super(RecognizeVerificationcodeAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.image_urlobject is not None:
result['ImageURLObject'] = self.image_urlobject
return result
def from_map(self, m=None):
m = m or dict()
if m.get('ImageURLObject') is not None:
self.image_urlobject = m.get('ImageURLObject')
return self
class RecognizeVerificationcodeResponseBodyData(TeaModel):
def __init__(self, content=None):
self.content = content # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeVerificationcodeResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.content is not None:
result['Content'] = self.content
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Content') is not None:
self.content = m.get('Content')
return self
class RecognizeVerificationcodeResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeVerificationcodeResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeVerificationcodeResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeVerificationcodeResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeVerificationcodeResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeVerificationcodeResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeVerificationcodeResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeVerificationcodeResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class RecognizeVideoCharacterRequest(TeaModel):
def __init__(self, video_url=None):
# 视频文件地址
self.video_url = video_url # type: str
def validate(self):
pass
def to_map(self):
_map = super(RecognizeVideoCharacterRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.video_url is not None:
result['VideoURL'] = self.video_url
return result
def from_map(self, m=None):
m = m or dict()
if m.get('VideoURL') is not None:
self.video_url = m.get('VideoURL')
return self
class RecognizeVideoCharacterResponseBodyDataFramesElementsTextRectangles(TeaModel):
def __init__(self, angle=None, height=None, left=None, top=None, width=None):
# 文字区域角度，角度范围[0, 360]
self.angle = angle # type: long
# 文字区域高度
self.height = height # type: long
# 文字区域左上角x坐标
self.left = left # type: long
# 文字区域左上角y坐标
self.top = top # type: long
# 文字区域宽度
self.width = width # type: long
def validate(self):
pass
def to_map(self):
_map = super(RecognizeVideoCharacterResponseBodyDataFramesElementsTextRectangles, self).to_map()
if _map is not None:
return _map
result = dict()
if self.angle is not None:
result['Angle'] = self.angle
if self.height is not None:
result['Height'] = self.height
if self.left is not None:
result['Left'] = self.left
if self.top is not None:
result['Top'] = self.top
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Angle') is not None:
self.angle = m.get('Angle')
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('Left') is not None:
self.left = m.get('Left')
if m.get('Top') is not None:
self.top = m.get('Top')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeVideoCharacterResponseBodyDataFramesElements(TeaModel):
def __init__(self, score=None, text=None, text_rectangles=None):
# 文字区域概率，概率值的范围为[0.0, 1.0]
self.score = score # type: float
# 文字内容
self.text = text # type: str
self.text_rectangles = text_rectangles # type: list[RecognizeVideoCharacterResponseBodyDataFramesElementsTextRectangles]
def validate(self):
if self.text_rectangles:
for k in self.text_rectangles:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeVideoCharacterResponseBodyDataFramesElements, self).to_map()
if _map is not None:
return _map
result = dict()
if self.score is not None:
result['Score'] = self.score
if self.text is not None:
result['Text'] = self.text
result['TextRectangles'] = []
if self.text_rectangles is not None:
for k in self.text_rectangles:
result['TextRectangles'].append(k.to_map() if k else None)
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Score') is not None:
self.score = m.get('Score')
if m.get('Text') is not None:
self.text = m.get('Text')
self.text_rectangles = []
if m.get('TextRectangles') is not None:
for k in m.get('TextRectangles'):
temp_model = RecognizeVideoCharacterResponseBodyDataFramesElementsTextRectangles()
self.text_rectangles.append(temp_model.from_map(k))
return self
class RecognizeVideoCharacterResponseBodyDataFrames(TeaModel):
def __init__(self, elements=None, timestamp=None):
self.elements = elements # type: list[RecognizeVideoCharacterResponseBodyDataFramesElements]
# 帧时间戳时间戳，单位秒。
self.timestamp = timestamp # type: long
def validate(self):
if self.elements:
for k in self.elements:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeVideoCharacterResponseBodyDataFrames, self).to_map()
if _map is not None:
return _map
result = dict()
result['Elements'] = []
if self.elements is not None:
for k in self.elements:
result['Elements'].append(k.to_map() if k else None)
if self.timestamp is not None:
result['Timestamp'] = self.timestamp
return result
def from_map(self, m=None):
m = m or dict()
self.elements = []
if m.get('Elements') is not None:
for k in m.get('Elements'):
temp_model = RecognizeVideoCharacterResponseBodyDataFramesElements()
self.elements.append(temp_model.from_map(k))
if m.get('Timestamp') is not None:
self.timestamp = m.get('Timestamp')
return self
class RecognizeVideoCharacterResponseBodyData(TeaModel):
def __init__(self, frames=None, height=None, input_file=None, width=None):
# 视频帧的集合，空信息的帧不列出。
self.frames = frames # type: list[RecognizeVideoCharacterResponseBodyDataFrames]
self.height = height # type: long
# 对应的输入OSS文件 (格式oss://{bucketName}/{object})
self.input_file = input_file # type: str
self.width = width # type: long
def validate(self):
if self.frames:
for k in self.frames:
if k:
k.validate()
def to_map(self):
_map = super(RecognizeVideoCharacterResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
result['Frames'] = []
if self.frames is not None:
for k in self.frames:
result['Frames'].append(k.to_map() if k else None)
if self.height is not None:
result['Height'] = self.height
if self.input_file is not None:
result['InputFile'] = self.input_file
if self.width is not None:
result['Width'] = self.width
return result
def from_map(self, m=None):
m = m or dict()
self.frames = []
if m.get('Frames') is not None:
for k in m.get('Frames'):
temp_model = RecognizeVideoCharacterResponseBodyDataFrames()
self.frames.append(temp_model.from_map(k))
if m.get('Height') is not None:
self.height = m.get('Height')
if m.get('InputFile') is not None:
self.input_file = m.get('InputFile')
if m.get('Width') is not None:
self.width = m.get('Width')
return self
class RecognizeVideoCharacterResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: RecognizeVideoCharacterResponseBodyData
# Id of the request
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(RecognizeVideoCharacterResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = RecognizeVideoCharacterResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class RecognizeVideoCharacterResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: RecognizeVideoCharacterResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(RecognizeVideoCharacterResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = RecognizeVideoCharacterResponseBody()
self.body = temp_model.from_map(m['body'])
return self
class TrimDocumentRequest(TeaModel):
def __init__(self, file_type=None, file_url=None, output_type=None):
self.file_type = file_type # type: str
self.file_url = file_url # type: str
self.output_type = output_type # type: str
def validate(self):
pass
def to_map(self):
_map = super(TrimDocumentRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.file_type is not None:
result['FileType'] = self.file_type
if self.file_url is not None:
result['FileURL'] = self.file_url
if self.output_type is not None:
result['OutputType'] = self.output_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('FileType') is not None:
self.file_type = m.get('FileType')
if m.get('FileURL') is not None:
self.file_url = m.get('FileURL')
if m.get('OutputType') is not None:
self.output_type = m.get('OutputType')
return self
class TrimDocumentAdvanceRequest(TeaModel):
def __init__(self, file_urlobject=None, file_type=None, output_type=None):
self.file_urlobject = file_urlobject # type: READABLE
self.file_type = file_type # type: str
self.output_type = output_type # type: str
def validate(self):
self.validate_required(self.file_urlobject, 'file_urlobject')
def to_map(self):
_map = super(TrimDocumentAdvanceRequest, self).to_map()
if _map is not None:
return _map
result = dict()
if self.file_urlobject is not None:
result['FileURLObject'] = self.file_urlobject
if self.file_type is not None:
result['FileType'] = self.file_type
if self.output_type is not None:
result['OutputType'] = self.output_type
return result
def from_map(self, m=None):
m = m or dict()
if m.get('FileURLObject') is not None:
self.file_urlobject = m.get('FileURLObject')
if m.get('FileType') is not None:
self.file_type = m.get('FileType')
if m.get('OutputType') is not None:
self.output_type = m.get('OutputType')
return self
class TrimDocumentResponseBodyData(TeaModel):
def __init__(self, content=None):
self.content = content # type: str
def validate(self):
pass
def to_map(self):
_map = super(TrimDocumentResponseBodyData, self).to_map()
if _map is not None:
return _map
result = dict()
if self.content is not None:
result['Content'] = self.content
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Content') is not None:
self.content = m.get('Content')
return self
class TrimDocumentResponseBody(TeaModel):
def __init__(self, data=None, request_id=None):
self.data = data # type: TrimDocumentResponseBodyData
self.request_id = request_id # type: str
def validate(self):
if self.data:
self.data.validate()
def to_map(self):
_map = super(TrimDocumentResponseBody, self).to_map()
if _map is not None:
return _map
result = dict()
if self.data is not None:
result['Data'] = self.data.to_map()
if self.request_id is not None:
result['RequestId'] = self.request_id
return result
def from_map(self, m=None):
m = m or dict()
if m.get('Data') is not None:
temp_model = TrimDocumentResponseBodyData()
self.data = temp_model.from_map(m['Data'])
if m.get('RequestId') is not None:
self.request_id = m.get('RequestId')
return self
class TrimDocumentResponse(TeaModel):
def __init__(self, headers=None, body=None):
self.headers = headers # type: dict[str, str]
self.body = body # type: TrimDocumentResponseBody
def validate(self):
self.validate_required(self.headers, 'headers')
self.validate_required(self.body, 'body')
if self.body:
self.body.validate()
def to_map(self):
_map = super(TrimDocumentResponse, self).to_map()
if _map is not None:
return _map
result = dict()
if self.headers is not None:
result['headers'] = self.headers
if self.body is not None:
result['body'] = self.body.to_map()
return result
def from_map(self, m=None):
m = m or dict()
if m.get('headers') is not None:
self.headers = m.get('headers')
if m.get('body') is not None:
temp_model = TrimDocumentResponseBody()
self.body = temp_model.from_map(m['body'])
return self