tccli 3.0.1297.1__py2.py3-none-any.whl → 3.0.1299.1__py2.py3-none-any.whl

tccli/services/ocr/ocr_client.py

@@ -17,7 +17,7 @@ from tencentcloud.ocr.v20181119 import models as models_v20181119
 from jmespath import search
 import time
 
-def doQuestionOCR(args, parsed_globals):
+def doInsuranceBillOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -46,11 +46,11 @@ def doQuestionOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.QuestionOCRRequest()
+    model = models.InsuranceBillOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.QuestionOCR(model)
+        rsp = client.InsuranceBillOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -69,7 +69,7 @@ def doQuestionOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doTextDetect(args, parsed_globals):
+def doImageEnhancement(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -98,11 +98,11 @@ def doTextDetect(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.TextDetectRequest()
+    model = models.ImageEnhancementRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.TextDetect(model)
+        rsp = client.ImageEnhancement(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -121,7 +121,7 @@ def doTextDetect(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doQrcodeOCR(args, parsed_globals):
+def doQuestionSplitOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -150,11 +150,11 @@ def doQrcodeOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.QrcodeOCRRequest()
+    model = models.QuestionSplitOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.QrcodeOCR(model)
+        rsp = client.QuestionSplitOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -173,7 +173,7 @@ def doQrcodeOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doGeneralAccurateOCR(args, parsed_globals):
+def doSmartStructuralOCRV2(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -202,11 +202,11 @@ def doGeneralAccurateOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.GeneralAccurateOCRRequest()
+    model = models.SmartStructuralOCRV2Request()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.GeneralAccurateOCR(model)
+        rsp = client.SmartStructuralOCRV2(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -225,7 +225,7 @@ def doGeneralAccurateOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeContainerOCR(args, parsed_globals):
+def doEnterpriseLicenseOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -254,11 +254,11 @@ def doRecognizeContainerOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeContainerOCRRequest()
+    model = models.EnterpriseLicenseOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeContainerOCR(model)
+        rsp = client.EnterpriseLicenseOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -277,7 +277,7 @@ def doRecognizeContainerOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeEncryptedIDCardOCR(args, parsed_globals):
+def doBusinessCardOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -306,11 +306,11 @@ def doRecognizeEncryptedIDCardOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeEncryptedIDCardOCRRequest()
+    model = models.BusinessCardOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeEncryptedIDCardOCR(model)
+        rsp = client.BusinessCardOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -329,7 +329,7 @@ def doRecognizeEncryptedIDCardOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeStoreName(args, parsed_globals):
+def doIDCardOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -358,11 +358,11 @@ def doRecognizeStoreName(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeStoreNameRequest()
+    model = models.IDCardOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeStoreName(model)
+        rsp = client.IDCardOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -381,7 +381,7 @@ def doRecognizeStoreName(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doMLIDPassportOCR(args, parsed_globals):
+def doPassportOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -410,11 +410,11 @@ def doMLIDPassportOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.MLIDPassportOCRRequest()
+    model = models.PassportOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.MLIDPassportOCR(model)
+        rsp = client.PassportOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -433,7 +433,7 @@ def doMLIDPassportOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doTrainTicketOCR(args, parsed_globals):
+def doMLIDCardOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -462,11 +462,11 @@ def doTrainTicketOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.TrainTicketOCRRequest()
+    model = models.MLIDCardOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.TrainTicketOCR(model)
+        rsp = client.MLIDCardOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -485,7 +485,7 @@ def doTrainTicketOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doPropOwnerCertOCR(args, parsed_globals):
+def doVatInvoiceVerifyNew(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -514,11 +514,11 @@ def doPropOwnerCertOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.PropOwnerCertOCRRequest()
+    model = models.VatInvoiceVerifyNewRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.PropOwnerCertOCR(model)
+        rsp = client.VatInvoiceVerifyNew(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -537,7 +537,7 @@ def doPropOwnerCertOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doInvoiceGeneralOCR(args, parsed_globals):
+def doQrcodeOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -566,11 +566,11 @@ def doInvoiceGeneralOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.InvoiceGeneralOCRRequest()
+    model = models.QrcodeOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.InvoiceGeneralOCR(model)
+        rsp = client.QrcodeOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -589,7 +589,7 @@ def doInvoiceGeneralOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doReconstructDocument(args, parsed_globals):
+def doGeneralAccurateOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -618,11 +618,11 @@ def doReconstructDocument(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.ReconstructDocumentRequest()
+    model = models.GeneralAccurateOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.ReconstructDocument(model)
+        rsp = client.GeneralAccurateOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -641,7 +641,7 @@ def doReconstructDocument(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doHKIDCardOCR(args, parsed_globals):
+def doMixedInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -670,11 +670,11 @@ def doHKIDCardOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.HKIDCardOCRRequest()
+    model = models.MixedInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.HKIDCardOCR(model)
+        rsp = client.MixedInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -693,7 +693,7 @@ def doHKIDCardOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doMixedInvoiceOCR(args, parsed_globals):
+def doRecognizeContainerOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -722,11 +722,11 @@ def doMixedInvoiceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.MixedInvoiceOCRRequest()
+    model = models.RecognizeContainerOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.MixedInvoiceOCR(model)
+        rsp = client.RecognizeContainerOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -745,7 +745,7 @@ def doMixedInvoiceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doPermitOCR(args, parsed_globals):
+def doRecognizeTableAccurateOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -774,11 +774,11 @@ def doPermitOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.PermitOCRRequest()
+    model = models.RecognizeTableAccurateOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.PermitOCR(model)
+        rsp = client.RecognizeTableAccurateOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -797,7 +797,7 @@ def doPermitOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doBusInvoiceOCR(args, parsed_globals):
+def doRecognizeEncryptedIDCardOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -826,11 +826,11 @@ def doBusInvoiceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.BusInvoiceOCRRequest()
+    model = models.RecognizeEncryptedIDCardOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.BusInvoiceOCR(model)
+        rsp = client.RecognizeEncryptedIDCardOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -849,7 +849,7 @@ def doBusInvoiceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doEnglishOCR(args, parsed_globals):
+def doMixedInvoiceDetect(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -878,11 +878,11 @@ def doEnglishOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.EnglishOCRRequest()
+    model = models.MixedInvoiceDetectRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.EnglishOCR(model)
+        rsp = client.MixedInvoiceDetect(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -901,7 +901,7 @@ def doEnglishOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doSmartStructuralOCR(args, parsed_globals):
+def doVinOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -930,11 +930,11 @@ def doSmartStructuralOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.SmartStructuralOCRRequest()
+    model = models.VinOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.SmartStructuralOCR(model)
+        rsp = client.VinOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -953,7 +953,7 @@ def doSmartStructuralOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doClassifyStoreName(args, parsed_globals):
+def doRecognizeStoreName(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -982,11 +982,11 @@ def doClassifyStoreName(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.ClassifyStoreNameRequest()
+    model = models.RecognizeStoreNameRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.ClassifyStoreName(model)
+        rsp = client.RecognizeStoreName(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1005,7 +1005,7 @@ def doClassifyStoreName(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doTaxiInvoiceOCR(args, parsed_globals):
+def doMLIDPassportOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1034,11 +1034,11 @@ def doTaxiInvoiceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.TaxiInvoiceOCRRequest()
+    model = models.MLIDPassportOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.TaxiInvoiceOCR(model)
+        rsp = client.MLIDPassportOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1057,7 +1057,7 @@ def doTaxiInvoiceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRideHailingDriverLicenseOCR(args, parsed_globals):
+def doVatRollInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1086,11 +1086,11 @@ def doRideHailingDriverLicenseOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RideHailingDriverLicenseOCRRequest()
+    model = models.VatRollInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RideHailingDriverLicenseOCR(model)
+        rsp = client.VatRollInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1109,7 +1109,7 @@ def doRideHailingDriverLicenseOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doDutyPaidProofOCR(args, parsed_globals):
+def doVehicleLicenseOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1138,11 +1138,11 @@ def doDutyPaidProofOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.DutyPaidProofOCRRequest()
+    model = models.VehicleLicenseOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.DutyPaidProofOCR(model)
+        rsp = client.VehicleLicenseOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1161,7 +1161,7 @@ def doDutyPaidProofOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doMainlandPermitOCR(args, parsed_globals):
+def doQuotaInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1190,11 +1190,11 @@ def doMainlandPermitOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.MainlandPermitOCRRequest()
+    model = models.QuotaInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.MainlandPermitOCR(model)
+        rsp = client.QuotaInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1213,7 +1213,7 @@ def doMainlandPermitOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doFlightInvoiceOCR(args, parsed_globals):
+def doFinanBillOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1242,11 +1242,11 @@ def doFlightInvoiceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.FlightInvoiceOCRRequest()
+    model = models.FinanBillOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.FlightInvoiceOCR(model)
+        rsp = client.FinanBillOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1265,7 +1265,7 @@ def doFlightInvoiceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeGeneralInvoice(args, parsed_globals):
+def doGeneralFastOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1294,11 +1294,11 @@ def doRecognizeGeneralInvoice(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeGeneralInvoiceRequest()
+    model = models.GeneralFastOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeGeneralInvoice(model)
+        rsp = client.GeneralFastOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1317,7 +1317,7 @@ def doRecognizeGeneralInvoice(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doInsuranceBillOCR(args, parsed_globals):
+def doPropOwnerCertOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1346,11 +1346,11 @@ def doInsuranceBillOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.InsuranceBillOCRRequest()
+    model = models.PropOwnerCertOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.InsuranceBillOCR(model)
+        rsp = client.PropOwnerCertOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1369,7 +1369,7 @@ def doInsuranceBillOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doVatInvoiceVerifyNew(args, parsed_globals):
+def doRecognizeThaiIDCardOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1398,11 +1398,11 @@ def doVatInvoiceVerifyNew(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.VatInvoiceVerifyNewRequest()
+    model = models.RecognizeThaiIDCardOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.VatInvoiceVerifyNew(model)
+        rsp = client.RecognizeThaiIDCardOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1421,7 +1421,7 @@ def doVatInvoiceVerifyNew(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doVinOCR(args, parsed_globals):
+def doBizLicenseOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1450,11 +1450,11 @@ def doVinOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.VinOCRRequest()
+    model = models.BizLicenseOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.VinOCR(model)
+        rsp = client.BizLicenseOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1473,7 +1473,7 @@ def doVinOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doVehicleLicenseOCR(args, parsed_globals):
+def doGeneralHandwritingOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1502,11 +1502,11 @@ def doVehicleLicenseOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.VehicleLicenseOCRRequest()
+    model = models.GeneralHandwritingOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.VehicleLicenseOCR(model)
+        rsp = client.GeneralHandwritingOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1525,7 +1525,7 @@ def doVehicleLicenseOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doBizLicenseOCR(args, parsed_globals):
+def doQuestionOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1554,11 +1554,11 @@ def doBizLicenseOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.BizLicenseOCRRequest()
+    model = models.QuestionOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.BizLicenseOCR(model)
+        rsp = client.QuestionOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1577,7 +1577,7 @@ def doBizLicenseOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeGeneralCardWarn(args, parsed_globals):
+def doAdvertiseOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1606,11 +1606,11 @@ def doRecognizeGeneralCardWarn(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeGeneralCardWarnRequest()
+    model = models.AdvertiseOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeGeneralCardWarn(model)
+        rsp = client.AdvertiseOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1629,7 +1629,7 @@ def doRecognizeGeneralCardWarn(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doGeneralBasicOCR(args, parsed_globals):
+def doInvoiceGeneralOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1658,11 +1658,11 @@ def doGeneralBasicOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.GeneralBasicOCRRequest()
+    model = models.InvoiceGeneralOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.GeneralBasicOCR(model)
+        rsp = client.InvoiceGeneralOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1681,7 +1681,7 @@ def doGeneralBasicOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeThaiIDCardOCR(args, parsed_globals):
+def doTrainTicketOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1710,11 +1710,11 @@ def doRecognizeThaiIDCardOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeThaiIDCardOCRRequest()
+    model = models.TrainTicketOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeThaiIDCardOCR(model)
+        rsp = client.TrainTicketOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1733,7 +1733,7 @@ def doRecognizeThaiIDCardOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doTableOCR(args, parsed_globals):
+def doRecognizeOnlineTaxiItineraryOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1762,11 +1762,11 @@ def doTableOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.TableOCRRequest()
+    model = models.RecognizeOnlineTaxiItineraryOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.TableOCR(model)
+        rsp = client.RecognizeOnlineTaxiItineraryOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1785,7 +1785,7 @@ def doTableOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doArithmeticOCR(args, parsed_globals):
+def doHKIDCardOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1814,11 +1814,11 @@ def doArithmeticOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.ArithmeticOCRRequest()
+    model = models.HKIDCardOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.ArithmeticOCR(model)
+        rsp = client.HKIDCardOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1837,7 +1837,7 @@ def doArithmeticOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doEstateCertOCR(args, parsed_globals):
+def doVatInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1866,11 +1866,11 @@ def doEstateCertOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.EstateCertOCRRequest()
+    model = models.VatInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.EstateCertOCR(model)
+        rsp = client.VatInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1889,7 +1889,7 @@ def doEstateCertOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeValidIDCardOCR(args, parsed_globals):
+def doRecognizeGeneralCardWarn(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1918,11 +1918,11 @@ def doRecognizeValidIDCardOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeValidIDCardOCRRequest()
+    model = models.RecognizeGeneralCardWarnRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeValidIDCardOCR(model)
+        rsp = client.RecognizeGeneralCardWarn(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1941,7 +1941,7 @@ def doRecognizeValidIDCardOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doBankCardOCR(args, parsed_globals):
+def doRecognizeValidIDCardOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1970,11 +1970,11 @@ def doBankCardOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.BankCardOCRRequest()
+    model = models.RecognizeValidIDCardOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.BankCardOCR(model)
+        rsp = client.RecognizeValidIDCardOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -1993,7 +1993,7 @@ def doBankCardOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doGetOCRToken(args, parsed_globals):
+def doWaybillOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2022,11 +2022,11 @@ def doGetOCRToken(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.GetOCRTokenRequest()
+    model = models.WaybillOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.GetOCRToken(model)
+        rsp = client.WaybillOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2045,7 +2045,7 @@ def doGetOCRToken(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doEduPaperOCR(args, parsed_globals):
+def doFlightInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2074,11 +2074,11 @@ def doEduPaperOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.EduPaperOCRRequest()
+    model = models.FlightInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.EduPaperOCR(model)
+        rsp = client.FlightInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2097,7 +2097,7 @@ def doEduPaperOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doEnterpriseLicenseOCR(args, parsed_globals):
+def doPermitOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2126,11 +2126,11 @@ def doEnterpriseLicenseOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.EnterpriseLicenseOCRRequest()
+    model = models.PermitOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.EnterpriseLicenseOCR(model)
+        rsp = client.PermitOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2149,7 +2149,7 @@ def doEnterpriseLicenseOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doBusinessCardOCR(args, parsed_globals):
+def doRecognizeTableOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2178,11 +2178,11 @@ def doBusinessCardOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.BusinessCardOCRRequest()
+    model = models.RecognizeTableOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.BusinessCardOCR(model)
+        rsp = client.RecognizeTableOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2201,7 +2201,7 @@ def doBusinessCardOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doIDCardOCR(args, parsed_globals):
+def doTextDetect(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2230,11 +2230,11 @@ def doIDCardOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.IDCardOCRRequest()
+    model = models.TextDetectRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.IDCardOCR(model)
+        rsp = client.TextDetect(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2253,7 +2253,7 @@ def doIDCardOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeGeneralTextImageWarn(args, parsed_globals):
+def doBusInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2282,11 +2282,11 @@ def doRecognizeGeneralTextImageWarn(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeGeneralTextImageWarnRequest()
+    model = models.BusInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeGeneralTextImageWarn(model)
+        rsp = client.BusInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2305,7 +2305,7 @@ def doRecognizeGeneralTextImageWarn(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doInstitutionOCR(args, parsed_globals):
+def doTableOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2334,11 +2334,11 @@ def doInstitutionOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.InstitutionOCRRequest()
+    model = models.TableOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.InstitutionOCR(model)
+        rsp = client.TableOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2357,7 +2357,7 @@ def doInstitutionOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doSmartStructuralOCRV2(args, parsed_globals):
+def doEnglishOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2386,11 +2386,11 @@ def doSmartStructuralOCRV2(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.SmartStructuralOCRV2Request()
+    model = models.EnglishOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.SmartStructuralOCRV2(model)
+        rsp = client.EnglishOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2409,7 +2409,7 @@ def doSmartStructuralOCRV2(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeTableAccurateOCR(args, parsed_globals):
+def doHmtResidentPermitOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2438,11 +2438,11 @@ def doRecognizeTableAccurateOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeTableAccurateOCRRequest()
+    model = models.HmtResidentPermitOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeTableAccurateOCR(model)
+        rsp = client.HmtResidentPermitOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2461,7 +2461,7 @@ def doRecognizeTableAccurateOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doMixedInvoiceDetect(args, parsed_globals):
+def doRecognizeGeneralTextImageWarn(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2490,11 +2490,11 @@ def doMixedInvoiceDetect(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.MixedInvoiceDetectRequest()
+    model = models.RecognizeGeneralTextImageWarnRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.MixedInvoiceDetect(model)
+        rsp = client.RecognizeGeneralTextImageWarn(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2513,7 +2513,7 @@ def doMixedInvoiceDetect(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doVatRollInvoiceOCR(args, parsed_globals):
+def doSmartStructuralOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2542,11 +2542,11 @@ def doVatRollInvoiceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.VatRollInvoiceOCRRequest()
+    model = models.SmartStructuralOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.VatRollInvoiceOCR(model)
+        rsp = client.SmartStructuralOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2565,7 +2565,7 @@ def doVatRollInvoiceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doQuotaInvoiceOCR(args, parsed_globals):
+def doArithmeticOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2594,11 +2594,11 @@ def doQuotaInvoiceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.QuotaInvoiceOCRRequest()
+    model = models.ArithmeticOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.QuotaInvoiceOCR(model)
+        rsp = client.ArithmeticOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2617,7 +2617,7 @@ def doQuotaInvoiceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doGeneralHandwritingOCR(args, parsed_globals):
+def doTollInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2646,11 +2646,11 @@ def doGeneralHandwritingOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.GeneralHandwritingOCRRequest()
+    model = models.TollInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.GeneralHandwritingOCR(model)
+        rsp = client.TollInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2669,7 +2669,7 @@ def doGeneralHandwritingOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeOnlineTaxiItineraryOCR(args, parsed_globals):
+def doEstateCertOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2698,11 +2698,11 @@ def doRecognizeOnlineTaxiItineraryOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeOnlineTaxiItineraryOCRRequest()
+    model = models.EstateCertOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeOnlineTaxiItineraryOCR(model)
+        rsp = client.EstateCertOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2721,7 +2721,7 @@ def doRecognizeOnlineTaxiItineraryOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeTableOCR(args, parsed_globals):
+def doClassifyDetectOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2750,11 +2750,11 @@ def doRecognizeTableOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeTableOCRRequest()
+    model = models.ClassifyDetectOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeTableOCR(model)
+        rsp = client.ClassifyDetectOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2773,7 +2773,7 @@ def doRecognizeTableOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doWaybillOCR(args, parsed_globals):
+def doOrgCodeCertOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2802,11 +2802,11 @@ def doWaybillOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.WaybillOCRRequest()
+    model = models.OrgCodeCertOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.WaybillOCR(model)
+        rsp = client.OrgCodeCertOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2825,7 +2825,7 @@ def doWaybillOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doHmtResidentPermitOCR(args, parsed_globals):
+def doSealOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2854,11 +2854,11 @@ def doHmtResidentPermitOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.HmtResidentPermitOCRRequest()
+    model = models.SealOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.HmtResidentPermitOCR(model)
+        rsp = client.SealOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2877,7 +2877,7 @@ def doHmtResidentPermitOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doTollInvoiceOCR(args, parsed_globals):
+def doRecognizeForeignPermanentResidentIdCard(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2906,11 +2906,11 @@ def doTollInvoiceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.TollInvoiceOCRRequest()
+    model = models.RecognizeForeignPermanentResidentIdCardRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.TollInvoiceOCR(model)
+        rsp = client.RecognizeForeignPermanentResidentIdCard(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2929,7 +2929,7 @@ def doTollInvoiceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doClassifyDetectOCR(args, parsed_globals):
+def doClassifyStoreName(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2958,11 +2958,11 @@ def doClassifyDetectOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.ClassifyDetectOCRRequest()
+    model = models.ClassifyStoreNameRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.ClassifyDetectOCR(model)
+        rsp = client.ClassifyStoreName(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -2981,7 +2981,7 @@ def doClassifyDetectOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeFormulaOCR(args, parsed_globals):
+def doBankSlipOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3010,11 +3010,11 @@ def doRecognizeFormulaOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeFormulaOCRRequest()
+    model = models.BankSlipOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeFormulaOCR(model)
+        rsp = client.BankSlipOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3033,7 +3033,7 @@ def doRecognizeFormulaOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doSealOCR(args, parsed_globals):
+def doGeneralEfficientOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3062,11 +3062,11 @@ def doSealOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.SealOCRRequest()
+    model = models.GeneralEfficientOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.SealOCR(model)
+        rsp = client.GeneralEfficientOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3085,7 +3085,7 @@ def doSealOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doBankSlipOCR(args, parsed_globals):
+def doTaxiInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3114,11 +3114,11 @@ def doBankSlipOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.BankSlipOCRRequest()
+    model = models.TaxiInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.BankSlipOCR(model)
+        rsp = client.TaxiInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3241,59 +3241,7 @@ def doRecognizeTravelCardOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doVerifyOfdVatInvoiceOCR(args, parsed_globals):
-    g_param = parse_global_arg(parsed_globals)
-
-    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
-        cred = credential.CVMRoleCredential()
-    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
-        cred = credential.STSAssumeRoleCredential(
-            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
-            g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
-        )
-    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
-        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
-    else:
-        cred = credential.Credential(
-            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
-        )
-    http_profile = HttpProfile(
-        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
-        reqMethod="POST",
-        endpoint=g_param[OptionsDefine.Endpoint],
-        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
-    )
-    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
-    if g_param[OptionsDefine.Language]:
-        profile.language = g_param[OptionsDefine.Language]
-    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
-    client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
-    client._sdkVersion += ("_CLI_" + __version__)
-    models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.VerifyOfdVatInvoiceOCRRequest()
-    model.from_json_string(json.dumps(args))
-    start_time = time.time()
-    while True:
-        rsp = client.VerifyOfdVatInvoiceOCR(model)
-        result = rsp.to_json_string()
-        try:
-            json_obj = json.loads(result)
-        except TypeError as e:
-            json_obj = json.loads(result.decode('utf-8'))  # python3.3
-        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
-            break
-        cur_time = time.time()
-        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
-            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
-            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
-            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
-        else:
-            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
-        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
-    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
-
-
-def doDriverLicenseOCR(args, parsed_globals):
+def doRecognizeMedicalInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3322,11 +3270,11 @@ def doDriverLicenseOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.DriverLicenseOCRRequest()
+    model = models.RecognizeMedicalInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.DriverLicenseOCR(model)
+        rsp = client.RecognizeMedicalInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3345,7 +3293,7 @@ def doDriverLicenseOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doFinanBillOCR(args, parsed_globals):
+def doRideHailingDriverLicenseOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3374,11 +3322,11 @@ def doFinanBillOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.FinanBillOCRRequest()
+    model = models.RideHailingDriverLicenseOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.FinanBillOCR(model)
+        rsp = client.RideHailingDriverLicenseOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3397,7 +3345,7 @@ def doFinanBillOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doSmartStructuralPro(args, parsed_globals):
+def doVehicleRegCertOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3426,11 +3374,11 @@ def doSmartStructuralPro(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.SmartStructuralProRequest()
+    model = models.VehicleRegCertOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.SmartStructuralPro(model)
+        rsp = client.VehicleRegCertOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3449,7 +3397,7 @@ def doSmartStructuralPro(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeHealthCodeOCR(args, parsed_globals):
+def doBankCardOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3478,11 +3426,11 @@ def doRecognizeHealthCodeOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeHealthCodeOCRRequest()
+    model = models.BankCardOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeHealthCodeOCR(model)
+        rsp = client.BankCardOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3501,7 +3449,7 @@ def doRecognizeHealthCodeOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doImageEnhancement(args, parsed_globals):
+def doCarInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3530,11 +3478,11 @@ def doImageEnhancement(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.ImageEnhancementRequest()
+    model = models.CarInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.ImageEnhancement(model)
+        rsp = client.CarInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3553,7 +3501,7 @@ def doImageEnhancement(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doQuestionSplitOCR(args, parsed_globals):
+def doGetOCRResult(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3582,11 +3530,11 @@ def doQuestionSplitOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.QuestionSplitOCRRequest()
+    model = models.GetOCRResultRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.QuestionSplitOCR(model)
+        rsp = client.GetOCRResult(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3605,7 +3553,7 @@ def doQuestionSplitOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doMLIDCardOCR(args, parsed_globals):
+def doMainlandPermitOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3634,11 +3582,11 @@ def doMLIDCardOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.MLIDCardOCRRequest()
+    model = models.MainlandPermitOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.MLIDCardOCR(model)
+        rsp = client.MainlandPermitOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3657,7 +3605,7 @@ def doMLIDCardOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeMedicalInvoiceOCR(args, parsed_globals):
+def doFinanBillSliceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3686,11 +3634,11 @@ def doRecognizeMedicalInvoiceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeMedicalInvoiceOCRRequest()
+    model = models.FinanBillSliceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeMedicalInvoiceOCR(model)
+        rsp = client.FinanBillSliceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3709,7 +3657,7 @@ def doRecognizeMedicalInvoiceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doGeneralFastOCR(args, parsed_globals):
+def doFormulaOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3738,11 +3686,11 @@ def doGeneralFastOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.GeneralFastOCRRequest()
+    model = models.FormulaOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.GeneralFastOCR(model)
+        rsp = client.FormulaOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3761,7 +3709,7 @@ def doGeneralFastOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doVatInvoiceOCR(args, parsed_globals):
+def doLicensePlateOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3790,11 +3738,11 @@ def doVatInvoiceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.VatInvoiceOCRRequest()
+    model = models.LicensePlateOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.VatInvoiceOCR(model)
+        rsp = client.LicensePlateOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3813,7 +3761,7 @@ def doVatInvoiceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRecognizeForeignPermanentResidentIdCard(args, parsed_globals):
+def doInstitutionOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3842,11 +3790,11 @@ def doRecognizeForeignPermanentResidentIdCard(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RecognizeForeignPermanentResidentIdCardRequest()
+    model = models.InstitutionOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RecognizeForeignPermanentResidentIdCard(model)
+        rsp = client.InstitutionOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3865,7 +3813,7 @@ def doRecognizeForeignPermanentResidentIdCard(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doOrgCodeCertOCR(args, parsed_globals):
+def doShipInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3894,11 +3842,11 @@ def doOrgCodeCertOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.OrgCodeCertOCRRequest()
+    model = models.ShipInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.OrgCodeCertOCR(model)
+        rsp = client.ShipInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3917,7 +3865,7 @@ def doOrgCodeCertOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doFinanBillSliceOCR(args, parsed_globals):
+def doGetOCRToken(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3946,11 +3894,11 @@ def doFinanBillSliceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.FinanBillSliceOCRRequest()
+    model = models.GetOCRTokenRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.FinanBillSliceOCR(model)
+        rsp = client.GetOCRToken(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -3969,7 +3917,7 @@ def doFinanBillSliceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doLicensePlateOCR(args, parsed_globals):
+def doVerifyOfdVatInvoiceOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -3998,11 +3946,11 @@ def doLicensePlateOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.LicensePlateOCRRequest()
+    model = models.VerifyOfdVatInvoiceOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.LicensePlateOCR(model)
+        rsp = client.VerifyOfdVatInvoiceOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -4021,7 +3969,7 @@ def doLicensePlateOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doGeneralEfficientOCR(args, parsed_globals):
+def doRecognizeHealthCodeOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -4050,11 +3998,11 @@ def doGeneralEfficientOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.GeneralEfficientOCRRequest()
+    model = models.RecognizeHealthCodeOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.GeneralEfficientOCR(model)
+        rsp = client.RecognizeHealthCodeOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -4073,7 +4021,7 @@ def doGeneralEfficientOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doAdvertiseOCR(args, parsed_globals):
+def doGeneralBasicOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -4102,11 +4050,11 @@ def doAdvertiseOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.AdvertiseOCRRequest()
+    model = models.GeneralBasicOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.AdvertiseOCR(model)
+        rsp = client.GeneralBasicOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -4125,7 +4073,7 @@ def doAdvertiseOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doVehicleRegCertOCR(args, parsed_globals):
+def doSmartStructuralPro(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -4154,11 +4102,11 @@ def doVehicleRegCertOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.VehicleRegCertOCRRequest()
+    model = models.SmartStructuralProRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.VehicleRegCertOCR(model)
+        rsp = client.SmartStructuralPro(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -4177,7 +4125,7 @@ def doVehicleRegCertOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doCarInvoiceOCR(args, parsed_globals):
+def doDriverLicenseOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -4206,11 +4154,11 @@ def doCarInvoiceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.CarInvoiceOCRRequest()
+    model = models.DriverLicenseOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.CarInvoiceOCR(model)
+        rsp = client.DriverLicenseOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -4229,7 +4177,7 @@ def doCarInvoiceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doGetOCRResult(args, parsed_globals):
+def doEduPaperOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -4258,11 +4206,11 @@ def doGetOCRResult(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.GetOCRResultRequest()
+    model = models.EduPaperOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.GetOCRResult(model)
+        rsp = client.EduPaperOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -4281,7 +4229,7 @@ def doGetOCRResult(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doFormulaOCR(args, parsed_globals):
+def doRideHailingTransportLicenseOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -4310,11 +4258,11 @@ def doFormulaOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.FormulaOCRRequest()
+    model = models.RideHailingTransportLicenseOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.FormulaOCR(model)
+        rsp = client.RideHailingTransportLicenseOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -4333,7 +4281,7 @@ def doFormulaOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doPassportOCR(args, parsed_globals):
+def doDutyPaidProofOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -4362,11 +4310,11 @@ def doPassportOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.PassportOCRRequest()
+    model = models.DutyPaidProofOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.PassportOCR(model)
+        rsp = client.DutyPaidProofOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -4385,7 +4333,7 @@ def doPassportOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doShipInvoiceOCR(args, parsed_globals):
+def doRecognizeGeneralInvoice(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -4414,11 +4362,11 @@ def doShipInvoiceOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.ShipInvoiceOCRRequest()
+    model = models.RecognizeGeneralInvoiceRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.ShipInvoiceOCR(model)
+        rsp = client.RecognizeGeneralInvoice(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -4437,7 +4385,7 @@ def doShipInvoiceOCR(args, parsed_globals):
     FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
 
 
-def doRideHailingTransportLicenseOCR(args, parsed_globals):
+def doRecognizeFormulaOCR(args, parsed_globals):
     g_param = parse_global_arg(parsed_globals)
 
     if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -4466,11 +4414,11 @@ def doRideHailingTransportLicenseOCR(args, parsed_globals):
     client = mod.OcrClient(cred, g_param[OptionsDefine.Region], profile)
     client._sdkVersion += ("_CLI_" + __version__)
     models = MODELS_MAP[g_param[OptionsDefine.Version]]
-    model = models.RideHailingTransportLicenseOCRRequest()
+    model = models.RecognizeFormulaOCRRequest()
     model.from_json_string(json.dumps(args))
     start_time = time.time()
     while True:
-        rsp = client.RideHailingTransportLicenseOCR(model)
+        rsp = client.RecognizeFormulaOCR(model)
         result = rsp.to_json_string()
         try:
             json_obj = json.loads(result)
@@ -4500,92 +4448,91 @@ MODELS_MAP = {
 }
 
 ACTION_MAP = {
-    "QuestionOCR": doQuestionOCR,
-    "TextDetect": doTextDetect,
+    "InsuranceBillOCR": doInsuranceBillOCR,
+    "ImageEnhancement": doImageEnhancement,
+    "QuestionSplitOCR": doQuestionSplitOCR,
+    "SmartStructuralOCRV2": doSmartStructuralOCRV2,
+    "EnterpriseLicenseOCR": doEnterpriseLicenseOCR,
+    "BusinessCardOCR": doBusinessCardOCR,
+    "IDCardOCR": doIDCardOCR,
+    "PassportOCR": doPassportOCR,
+    "MLIDCardOCR": doMLIDCardOCR,
+    "VatInvoiceVerifyNew": doVatInvoiceVerifyNew,
     "QrcodeOCR": doQrcodeOCR,
     "GeneralAccurateOCR": doGeneralAccurateOCR,
+    "MixedInvoiceOCR": doMixedInvoiceOCR,
     "RecognizeContainerOCR": doRecognizeContainerOCR,
+    "RecognizeTableAccurateOCR": doRecognizeTableAccurateOCR,
     "RecognizeEncryptedIDCardOCR": doRecognizeEncryptedIDCardOCR,
+    "MixedInvoiceDetect": doMixedInvoiceDetect,
+    "VinOCR": doVinOCR,
     "RecognizeStoreName": doRecognizeStoreName,
     "MLIDPassportOCR": doMLIDPassportOCR,
-    "TrainTicketOCR": doTrainTicketOCR,
+    "VatRollInvoiceOCR": doVatRollInvoiceOCR,
+    "VehicleLicenseOCR": doVehicleLicenseOCR,
+    "QuotaInvoiceOCR": doQuotaInvoiceOCR,
+    "FinanBillOCR": doFinanBillOCR,
+    "GeneralFastOCR": doGeneralFastOCR,
     "PropOwnerCertOCR": doPropOwnerCertOCR,
+    "RecognizeThaiIDCardOCR": doRecognizeThaiIDCardOCR,
+    "BizLicenseOCR": doBizLicenseOCR,
+    "GeneralHandwritingOCR": doGeneralHandwritingOCR,
+    "QuestionOCR": doQuestionOCR,
+    "AdvertiseOCR": doAdvertiseOCR,
     "InvoiceGeneralOCR": doInvoiceGeneralOCR,
-    "ReconstructDocument": doReconstructDocument,
+    "TrainTicketOCR": doTrainTicketOCR,
+    "RecognizeOnlineTaxiItineraryOCR": doRecognizeOnlineTaxiItineraryOCR,
     "HKIDCardOCR": doHKIDCardOCR,
-    "MixedInvoiceOCR": doMixedInvoiceOCR,
+    "VatInvoiceOCR": doVatInvoiceOCR,
+    "RecognizeGeneralCardWarn": doRecognizeGeneralCardWarn,
+    "RecognizeValidIDCardOCR": doRecognizeValidIDCardOCR,
+    "WaybillOCR": doWaybillOCR,
+    "FlightInvoiceOCR": doFlightInvoiceOCR,
     "PermitOCR": doPermitOCR,
+    "RecognizeTableOCR": doRecognizeTableOCR,
+    "TextDetect": doTextDetect,
     "BusInvoiceOCR": doBusInvoiceOCR,
+    "TableOCR": doTableOCR,
     "EnglishOCR": doEnglishOCR,
+    "HmtResidentPermitOCR": doHmtResidentPermitOCR,
+    "RecognizeGeneralTextImageWarn": doRecognizeGeneralTextImageWarn,
     "SmartStructuralOCR": doSmartStructuralOCR,
-    "ClassifyStoreName": doClassifyStoreName,
-    "TaxiInvoiceOCR": doTaxiInvoiceOCR,
-    "RideHailingDriverLicenseOCR": doRideHailingDriverLicenseOCR,
-    "DutyPaidProofOCR": doDutyPaidProofOCR,
-    "MainlandPermitOCR": doMainlandPermitOCR,
-    "FlightInvoiceOCR": doFlightInvoiceOCR,
-    "RecognizeGeneralInvoice": doRecognizeGeneralInvoice,
-    "InsuranceBillOCR": doInsuranceBillOCR,
-    "VatInvoiceVerifyNew": doVatInvoiceVerifyNew,
-    "VinOCR": doVinOCR,
-    "VehicleLicenseOCR": doVehicleLicenseOCR,
-    "BizLicenseOCR": doBizLicenseOCR,
-    "RecognizeGeneralCardWarn": doRecognizeGeneralCardWarn,
-    "GeneralBasicOCR": doGeneralBasicOCR,
-    "RecognizeThaiIDCardOCR": doRecognizeThaiIDCardOCR,
-    "TableOCR": doTableOCR,
     "ArithmeticOCR": doArithmeticOCR,
-    "EstateCertOCR": doEstateCertOCR,
-    "RecognizeValidIDCardOCR": doRecognizeValidIDCardOCR,
-    "BankCardOCR": doBankCardOCR,
-    "GetOCRToken": doGetOCRToken,
-    "EduPaperOCR": doEduPaperOCR,
-    "EnterpriseLicenseOCR": doEnterpriseLicenseOCR,
-    "BusinessCardOCR": doBusinessCardOCR,
-    "IDCardOCR": doIDCardOCR,
-    "RecognizeGeneralTextImageWarn": doRecognizeGeneralTextImageWarn,
-    "InstitutionOCR": doInstitutionOCR,
-    "SmartStructuralOCRV2": doSmartStructuralOCRV2,
-    "RecognizeTableAccurateOCR": doRecognizeTableAccurateOCR,
-    "MixedInvoiceDetect": doMixedInvoiceDetect,
-    "VatRollInvoiceOCR": doVatRollInvoiceOCR,
-    "QuotaInvoiceOCR": doQuotaInvoiceOCR,
-    "GeneralHandwritingOCR": doGeneralHandwritingOCR,
-    "RecognizeOnlineTaxiItineraryOCR": doRecognizeOnlineTaxiItineraryOCR,
-    "RecognizeTableOCR": doRecognizeTableOCR,
-    "WaybillOCR": doWaybillOCR,
-    "HmtResidentPermitOCR": doHmtResidentPermitOCR,
     "TollInvoiceOCR": doTollInvoiceOCR,
+    "EstateCertOCR": doEstateCertOCR,
     "ClassifyDetectOCR": doClassifyDetectOCR,
-    "RecognizeFormulaOCR": doRecognizeFormulaOCR,
+    "OrgCodeCertOCR": doOrgCodeCertOCR,
     "SealOCR": doSealOCR,
+    "RecognizeForeignPermanentResidentIdCard": doRecognizeForeignPermanentResidentIdCard,
+    "ClassifyStoreName": doClassifyStoreName,
     "BankSlipOCR": doBankSlipOCR,
+    "GeneralEfficientOCR": doGeneralEfficientOCR,
+    "TaxiInvoiceOCR": doTaxiInvoiceOCR,
     "ResidenceBookletOCR": doResidenceBookletOCR,
     "RecognizeTravelCardOCR": doRecognizeTravelCardOCR,
-    "VerifyOfdVatInvoiceOCR": doVerifyOfdVatInvoiceOCR,
-    "DriverLicenseOCR": doDriverLicenseOCR,
-    "FinanBillOCR": doFinanBillOCR,
-    "SmartStructuralPro": doSmartStructuralPro,
-    "RecognizeHealthCodeOCR": doRecognizeHealthCodeOCR,
-    "ImageEnhancement": doImageEnhancement,
-    "QuestionSplitOCR": doQuestionSplitOCR,
-    "MLIDCardOCR": doMLIDCardOCR,
     "RecognizeMedicalInvoiceOCR": doRecognizeMedicalInvoiceOCR,
-    "GeneralFastOCR": doGeneralFastOCR,
-    "VatInvoiceOCR": doVatInvoiceOCR,
-    "RecognizeForeignPermanentResidentIdCard": doRecognizeForeignPermanentResidentIdCard,
-    "OrgCodeCertOCR": doOrgCodeCertOCR,
-    "FinanBillSliceOCR": doFinanBillSliceOCR,
-    "LicensePlateOCR": doLicensePlateOCR,
-    "GeneralEfficientOCR": doGeneralEfficientOCR,
-    "AdvertiseOCR": doAdvertiseOCR,
+    "RideHailingDriverLicenseOCR": doRideHailingDriverLicenseOCR,
     "VehicleRegCertOCR": doVehicleRegCertOCR,
+    "BankCardOCR": doBankCardOCR,
     "CarInvoiceOCR": doCarInvoiceOCR,
     "GetOCRResult": doGetOCRResult,
+    "MainlandPermitOCR": doMainlandPermitOCR,
+    "FinanBillSliceOCR": doFinanBillSliceOCR,
     "FormulaOCR": doFormulaOCR,
-    "PassportOCR": doPassportOCR,
+    "LicensePlateOCR": doLicensePlateOCR,
+    "InstitutionOCR": doInstitutionOCR,
     "ShipInvoiceOCR": doShipInvoiceOCR,
+    "GetOCRToken": doGetOCRToken,
+    "VerifyOfdVatInvoiceOCR": doVerifyOfdVatInvoiceOCR,
+    "RecognizeHealthCodeOCR": doRecognizeHealthCodeOCR,
+    "GeneralBasicOCR": doGeneralBasicOCR,
+    "SmartStructuralPro": doSmartStructuralPro,
+    "DriverLicenseOCR": doDriverLicenseOCR,
+    "EduPaperOCR": doEduPaperOCR,
     "RideHailingTransportLicenseOCR": doRideHailingTransportLicenseOCR,
+    "DutyPaidProofOCR": doDutyPaidProofOCR,
+    "RecognizeGeneralInvoice": doRecognizeGeneralInvoice,
+    "RecognizeFormulaOCR": doRecognizeFormulaOCR,
 
 }