volcengine-python-sdk 5.0.44__py2.py3-none-any.whl → 5.0.45__py2.py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- {volcengine_python_sdk-5.0.44.dist-info → volcengine_python_sdk-5.0.45.dist-info}/METADATA +1 -1
- {volcengine_python_sdk-5.0.44.dist-info → volcengine_python_sdk-5.0.45.dist-info}/RECORD +300 -31
- {volcengine_python_sdk-5.0.44.dist-info → volcengine_python_sdk-5.0.45.dist-info}/WHEEL +1 -1
- {volcengine_python_sdk-5.0.44.dist-info → volcengine_python_sdk-5.0.45.dist-info}/top_level.txt +1 -0
- volcenginesdkacep/__init__.py +3 -0
- volcenginesdkacep/api/acep_api.py +97 -0
- volcenginesdkacep/models/__init__.py +3 -0
- volcenginesdkacep/models/delete_pod_response.py +29 -1
- volcenginesdkacep/models/delete_port_mapping_rule_request.py +177 -0
- volcenginesdkacep/models/delete_port_mapping_rule_response.py +175 -0
- volcenginesdkacep/models/detail_for_delete_pod_output.py +201 -0
- volcenginesdkarkruntime/resources/content_generation/tasks.py +8 -0
- volcenginesdkarkruntime/types/content_generation/content_generation_task.py +3 -0
- volcenginesdkcore/api_client.py +1 -1
- volcenginesdkcore/configuration.py +1 -1
- volcenginesdkcore/endpoint/providers/default_provider.py +6 -0
- volcenginesdkcore/endpoint/providers/standard_provider.py +1 -0
- volcenginesdkcpaas/api/cpaas_api.py +2 -2
- volcenginesdkcpaas/models/create_template_v2_request.py +15 -41
- volcenginesdkcpaas/models/priority_for_send_batch_message_input.py +7 -0
- volcenginesdkcpaas/models/priority_for_send_message_input.py +7 -0
- volcenginesdkdms/__init__.py +5 -0
- volcenginesdkdms/api/dms_api.py +194 -0
- volcenginesdkdms/models/__init__.py +5 -0
- volcenginesdkdms/models/basic_config_for_create_data_migrate_task_input.py +53 -1
- volcenginesdkdms/models/basic_config_for_query_data_migrate_task_output.py +53 -1
- volcenginesdkdms/models/bucket_access_config_for_create_data_migrate_task_input.py +27 -1
- volcenginesdkdms/models/bucket_access_config_for_query_data_migrate_task_output.py +27 -1
- volcenginesdkdms/models/failed_object_for_list_failed_objects_output.py +253 -0
- volcenginesdkdms/models/list_failed_objects_request.py +124 -0
- volcenginesdkdms/models/list_failed_objects_response.py +149 -0
- volcenginesdkdms/models/retry_migrate_task_callback_request.py +124 -0
- volcenginesdkdms/models/retry_migrate_task_callback_response.py +95 -0
- volcenginesdkdms/models/target_for_query_data_migrate_task_output.py +27 -1
- volcenginesdki18nopenapi/models/base_resp_for_video_project_task_batch_start_ai_flow_output.py +3 -3
- volcenginesdki18nopenapi/models/sub_for_video_editor_save_subtitle_input.py +3 -3
- volcenginesdki18nopenapi/models/video_editor_batch_update_style_request.py +28 -1
- volcenginesdktidb/__init__.py +278 -0
- volcenginesdktidb/api/__init__.py +6 -0
- volcenginesdktidb/api/tidb_api.py +3138 -0
- volcenginesdktidb/models/__init__.py +274 -0
- volcenginesdktidb/models/access_key_for_cancel_export_task_output.py +149 -0
- volcenginesdktidb/models/access_key_for_create_export_task_input.py +149 -0
- volcenginesdktidb/models/access_key_for_create_export_task_output.py +149 -0
- volcenginesdktidb/models/access_key_for_create_import_task_input.py +149 -0
- volcenginesdktidb/models/access_key_for_create_import_task_output.py +149 -0
- volcenginesdktidb/models/access_key_for_delete_export_task_output.py +149 -0
- volcenginesdktidb/models/access_key_for_get_export_task_details_output.py +149 -0
- volcenginesdktidb/models/access_key_for_get_import_task_details_output.py +149 -0
- volcenginesdktidb/models/access_key_for_list_export_tasks_output.py +149 -0
- volcenginesdktidb/models/access_key_for_list_import_tasks_output.py +149 -0
- volcenginesdktidb/models/access_key_for_precheck_import_task_input.py +149 -0
- volcenginesdktidb/models/access_key_for_validate_import_task_input.py +149 -0
- volcenginesdktidb/models/all_completed_table_for_create_import_task_output.py +201 -0
- volcenginesdktidb/models/all_completed_table_for_get_import_task_details_output.py +201 -0
- volcenginesdktidb/models/all_completed_table_for_list_import_tasks_output.py +201 -0
- volcenginesdktidb/models/auto_scaling_for_restore_cluster_input.py +149 -0
- volcenginesdktidb/models/azure_blob_for_cancel_export_task_output.py +175 -0
- volcenginesdktidb/models/azure_blob_for_create_export_task_input.py +182 -0
- volcenginesdktidb/models/azure_blob_for_create_export_task_output.py +175 -0
- volcenginesdktidb/models/azure_blob_for_create_import_task_input.py +182 -0
- volcenginesdktidb/models/azure_blob_for_create_import_task_output.py +175 -0
- volcenginesdktidb/models/azure_blob_for_delete_export_task_output.py +175 -0
- volcenginesdktidb/models/azure_blob_for_get_export_task_details_output.py +175 -0
- volcenginesdktidb/models/azure_blob_for_get_import_task_details_output.py +175 -0
- volcenginesdktidb/models/azure_blob_for_list_export_tasks_output.py +175 -0
- volcenginesdktidb/models/azure_blob_for_list_import_tasks_output.py +175 -0
- volcenginesdktidb/models/azure_blob_for_precheck_import_task_input.py +182 -0
- volcenginesdktidb/models/azure_blob_for_validate_import_task_input.py +182 -0
- volcenginesdktidb/models/backup_for_get_backup_output.py +279 -0
- volcenginesdktidb/models/backup_for_list_backups_output.py +279 -0
- volcenginesdktidb/models/cancel_export_task_request.py +177 -0
- volcenginesdktidb/models/cancel_export_task_response.py +123 -0
- volcenginesdktidb/models/cancel_import_task_request.py +177 -0
- volcenginesdktidb/models/cancel_import_task_response.py +95 -0
- volcenginesdktidb/models/cluster_for_restore_cluster_input.py +208 -0
- volcenginesdktidb/models/column_for_create_import_task_input.py +149 -0
- volcenginesdktidb/models/column_for_create_import_task_output.py +149 -0
- volcenginesdktidb/models/column_for_get_import_task_details_output.py +149 -0
- volcenginesdktidb/models/column_for_list_import_tasks_output.py +149 -0
- volcenginesdktidb/models/column_for_precheck_import_task_input.py +149 -0
- volcenginesdktidb/models/column_for_validate_import_task_input.py +149 -0
- volcenginesdktidb/models/convert_target_table_for_precheck_import_task_output.py +227 -0
- volcenginesdktidb/models/create_export_task_request.py +228 -0
- volcenginesdktidb/models/create_export_task_response.py +123 -0
- volcenginesdktidb/models/create_import_task_request.py +202 -0
- volcenginesdktidb/models/create_import_task_response.py +123 -0
- volcenginesdktidb/models/create_import_upload_url_request.py +177 -0
- volcenginesdktidb/models/create_import_upload_url_response.py +175 -0
- volcenginesdktidb/models/creation_details_for_create_import_task_output.py +149 -0
- volcenginesdktidb/models/creation_details_for_get_import_task_details_output.py +149 -0
- volcenginesdktidb/models/creation_details_for_list_import_tasks_output.py +149 -0
- volcenginesdktidb/models/csv_format_for_cancel_export_task_output.py +201 -0
- volcenginesdktidb/models/csv_format_for_create_export_task_input.py +201 -0
- volcenginesdktidb/models/csv_format_for_create_export_task_output.py +201 -0
- volcenginesdktidb/models/csv_format_for_create_import_task_input.py +279 -0
- volcenginesdktidb/models/csv_format_for_create_import_task_output.py +279 -0
- volcenginesdktidb/models/csv_format_for_delete_export_task_output.py +201 -0
- volcenginesdktidb/models/csv_format_for_get_export_task_details_output.py +201 -0
- volcenginesdktidb/models/csv_format_for_get_import_task_details_output.py +279 -0
- volcenginesdktidb/models/csv_format_for_list_export_tasks_output.py +201 -0
- volcenginesdktidb/models/csv_format_for_list_import_tasks_output.py +279 -0
- volcenginesdktidb/models/csv_format_for_precheck_import_task_input.py +279 -0
- volcenginesdktidb/models/csv_format_for_preview_local_import_input.py +279 -0
- volcenginesdktidb/models/database_for_list_import_target_tables_output.py +149 -0
- volcenginesdktidb/models/delete_export_task_request.py +177 -0
- volcenginesdktidb/models/delete_export_task_response.py +123 -0
- volcenginesdktidb/models/event_for_list_events_output.py +357 -0
- volcenginesdktidb/models/export_for_cancel_export_task_output.py +435 -0
- volcenginesdktidb/models/export_for_create_export_task_output.py +435 -0
- volcenginesdktidb/models/export_for_delete_export_task_output.py +435 -0
- volcenginesdktidb/models/export_for_get_export_task_details_output.py +435 -0
- volcenginesdktidb/models/export_for_list_export_tasks_output.py +435 -0
- volcenginesdktidb/models/export_options_for_cancel_export_task_output.py +227 -0
- volcenginesdktidb/models/export_options_for_create_export_task_input.py +241 -0
- volcenginesdktidb/models/export_options_for_create_export_task_output.py +227 -0
- volcenginesdktidb/models/export_options_for_delete_export_task_output.py +227 -0
- volcenginesdktidb/models/export_options_for_get_export_task_details_output.py +227 -0
- volcenginesdktidb/models/export_options_for_list_export_tasks_output.py +227 -0
- volcenginesdktidb/models/filter_for_cancel_export_task_output.py +149 -0
- volcenginesdktidb/models/filter_for_create_export_task_input.py +149 -0
- volcenginesdktidb/models/filter_for_create_export_task_output.py +149 -0
- volcenginesdktidb/models/filter_for_delete_export_task_output.py +149 -0
- volcenginesdktidb/models/filter_for_get_export_task_details_output.py +149 -0
- volcenginesdktidb/models/filter_for_list_export_tasks_output.py +149 -0
- volcenginesdktidb/models/gcs_for_cancel_export_task_output.py +175 -0
- volcenginesdktidb/models/gcs_for_create_export_task_input.py +182 -0
- volcenginesdktidb/models/gcs_for_create_export_task_output.py +175 -0
- volcenginesdktidb/models/gcs_for_create_import_task_input.py +182 -0
- volcenginesdktidb/models/gcs_for_create_import_task_output.py +175 -0
- volcenginesdktidb/models/gcs_for_delete_export_task_output.py +175 -0
- volcenginesdktidb/models/gcs_for_get_export_task_details_output.py +175 -0
- volcenginesdktidb/models/gcs_for_get_import_task_details_output.py +175 -0
- volcenginesdktidb/models/gcs_for_list_export_tasks_output.py +175 -0
- volcenginesdktidb/models/gcs_for_list_import_tasks_output.py +175 -0
- volcenginesdktidb/models/gcs_for_precheck_import_task_input.py +182 -0
- volcenginesdktidb/models/gcs_for_validate_import_task_input.py +182 -0
- volcenginesdktidb/models/get_backup_request.py +177 -0
- volcenginesdktidb/models/get_backup_response.py +123 -0
- volcenginesdktidb/models/get_backup_retention_request.py +150 -0
- volcenginesdktidb/models/get_backup_retention_response.py +123 -0
- volcenginesdktidb/models/get_export_task_details_request.py +177 -0
- volcenginesdktidb/models/get_export_task_details_response.py +123 -0
- volcenginesdktidb/models/get_import_table_columns_request.py +204 -0
- volcenginesdktidb/models/get_import_table_columns_response.py +123 -0
- volcenginesdktidb/models/get_import_task_details_request.py +177 -0
- volcenginesdktidb/models/get_import_task_details_response.py +123 -0
- volcenginesdktidb/models/get_metrics_request.py +257 -0
- volcenginesdktidb/models/get_metrics_response.py +123 -0
- volcenginesdktidb/models/get_restore_progress_request.py +150 -0
- volcenginesdktidb/models/get_restore_progress_response.py +175 -0
- volcenginesdktidb/models/get_slow_query_details_request.py +306 -0
- volcenginesdktidb/models/get_slow_query_details_response.py +123 -0
- volcenginesdktidb/models/get_statement_plan_details_request.py +280 -0
- volcenginesdktidb/models/get_statement_plan_details_response.py +123 -0
- volcenginesdktidb/models/import_for_create_import_task_output.py +513 -0
- volcenginesdktidb/models/import_for_get_import_task_details_output.py +513 -0
- volcenginesdktidb/models/import_for_list_import_tasks_output.py +513 -0
- volcenginesdktidb/models/import_options_for_create_import_task_input.py +208 -0
- volcenginesdktidb/models/import_options_for_create_import_task_output.py +201 -0
- volcenginesdktidb/models/import_options_for_get_import_task_details_output.py +201 -0
- volcenginesdktidb/models/import_options_for_list_import_tasks_output.py +201 -0
- volcenginesdktidb/models/import_options_for_precheck_import_task_input.py +208 -0
- volcenginesdktidb/models/item_for_get_slow_query_details_output.py +1735 -0
- volcenginesdktidb/models/item_for_get_statement_plan_details_output.py +1085 -0
- volcenginesdktidb/models/item_for_list_slow_queries_output.py +357 -0
- volcenginesdktidb/models/item_for_list_statement_plans_output.py +357 -0
- volcenginesdktidb/models/item_for_list_statement_slow_queries_output.py +357 -0
- volcenginesdktidb/models/item_for_list_statements_output.py +565 -0
- volcenginesdktidb/models/list_backups_request.py +228 -0
- volcenginesdktidb/models/list_backups_response.py +175 -0
- volcenginesdktidb/models/list_events_request.py +312 -0
- volcenginesdktidb/models/list_events_response.py +149 -0
- volcenginesdktidb/models/list_export_tasks_request.py +228 -0
- volcenginesdktidb/models/list_export_tasks_response.py +175 -0
- volcenginesdktidb/models/list_import_supported_data_types_request.py +123 -0
- volcenginesdktidb/models/list_import_supported_data_types_response.py +123 -0
- volcenginesdktidb/models/list_import_target_tables_request.py +150 -0
- volcenginesdktidb/models/list_import_target_tables_response.py +123 -0
- volcenginesdktidb/models/list_import_tasks_request.py +228 -0
- volcenginesdktidb/models/list_import_tasks_response.py +175 -0
- volcenginesdktidb/models/list_regions_request.py +95 -0
- volcenginesdktidb/models/list_regions_response.py +123 -0
- volcenginesdktidb/models/list_slow_queries_request.py +462 -0
- volcenginesdktidb/models/list_slow_queries_response.py +123 -0
- volcenginesdktidb/models/list_statement_plans_request.py +254 -0
- volcenginesdktidb/models/list_statement_plans_response.py +123 -0
- volcenginesdktidb/models/list_statement_slow_queries_request.py +358 -0
- volcenginesdktidb/models/list_statement_slow_queries_response.py +123 -0
- volcenginesdktidb/models/list_statement_types_request.py +150 -0
- volcenginesdktidb/models/list_statement_types_response.py +123 -0
- volcenginesdktidb/models/list_statements_request.py +280 -0
- volcenginesdktidb/models/list_statements_response.py +123 -0
- volcenginesdktidb/models/list_zones_request.py +123 -0
- volcenginesdktidb/models/list_zones_response.py +149 -0
- volcenginesdktidb/models/local_for_create_import_task_input.py +253 -0
- volcenginesdktidb/models/local_for_create_import_task_output.py +253 -0
- volcenginesdktidb/models/local_for_get_import_task_details_output.py +253 -0
- volcenginesdktidb/models/local_for_list_import_tasks_output.py +253 -0
- volcenginesdktidb/models/local_for_precheck_import_task_input.py +253 -0
- volcenginesdktidb/models/local_for_validate_import_task_input.py +253 -0
- volcenginesdktidb/models/oss_for_cancel_export_task_output.py +175 -0
- volcenginesdktidb/models/oss_for_create_export_task_input.py +182 -0
- volcenginesdktidb/models/oss_for_create_export_task_output.py +175 -0
- volcenginesdktidb/models/oss_for_create_import_task_input.py +182 -0
- volcenginesdktidb/models/oss_for_create_import_task_output.py +175 -0
- volcenginesdktidb/models/oss_for_delete_export_task_output.py +175 -0
- volcenginesdktidb/models/oss_for_get_export_task_details_output.py +175 -0
- volcenginesdktidb/models/oss_for_get_import_task_details_output.py +175 -0
- volcenginesdktidb/models/oss_for_list_export_tasks_output.py +175 -0
- volcenginesdktidb/models/oss_for_list_import_tasks_output.py +175 -0
- volcenginesdktidb/models/oss_for_precheck_import_task_input.py +182 -0
- volcenginesdktidb/models/oss_for_validate_import_task_input.py +182 -0
- volcenginesdktidb/models/parquet_format_for_cancel_export_task_output.py +123 -0
- volcenginesdktidb/models/parquet_format_for_create_export_task_input.py +130 -0
- volcenginesdktidb/models/parquet_format_for_create_export_task_output.py +123 -0
- volcenginesdktidb/models/parquet_format_for_delete_export_task_output.py +123 -0
- volcenginesdktidb/models/parquet_format_for_get_export_task_details_output.py +123 -0
- volcenginesdktidb/models/parquet_format_for_list_export_tasks_output.py +123 -0
- volcenginesdktidb/models/point_in_time_for_restore_cluster_input.py +149 -0
- volcenginesdktidb/models/precheck_import_task_request.py +202 -0
- volcenginesdktidb/models/precheck_import_task_response.py +227 -0
- volcenginesdktidb/models/preview_local_import_request.py +237 -0
- volcenginesdktidb/models/preview_local_import_response.py +123 -0
- volcenginesdktidb/models/region_for_list_regions_output.py +227 -0
- volcenginesdktidb/models/restore_cluster_request.py +254 -0
- volcenginesdktidb/models/restore_cluster_response.py +123 -0
- volcenginesdktidb/models/row_value_for_get_import_table_columns_output.py +123 -0
- volcenginesdktidb/models/row_value_for_preview_local_import_output.py +123 -0
- volcenginesdktidb/models/ru_v2_metrics_for_get_slow_query_details_output.py +279 -0
- volcenginesdktidb/models/s3_compatible_for_create_import_task_input.py +208 -0
- volcenginesdktidb/models/s3_compatible_for_create_import_task_output.py +201 -0
- volcenginesdktidb/models/s3_compatible_for_get_import_task_details_output.py +201 -0
- volcenginesdktidb/models/s3_compatible_for_list_import_tasks_output.py +201 -0
- volcenginesdktidb/models/s3_compatible_for_precheck_import_task_input.py +208 -0
- volcenginesdktidb/models/s3_compatible_for_validate_import_task_input.py +208 -0
- volcenginesdktidb/models/s3_for_cancel_export_task_output.py +201 -0
- volcenginesdktidb/models/s3_for_create_export_task_input.py +208 -0
- volcenginesdktidb/models/s3_for_create_export_task_output.py +201 -0
- volcenginesdktidb/models/s3_for_create_import_task_input.py +208 -0
- volcenginesdktidb/models/s3_for_create_import_task_output.py +201 -0
- volcenginesdktidb/models/s3_for_delete_export_task_output.py +201 -0
- volcenginesdktidb/models/s3_for_get_export_task_details_output.py +201 -0
- volcenginesdktidb/models/s3_for_get_import_task_details_output.py +201 -0
- volcenginesdktidb/models/s3_for_list_export_tasks_output.py +201 -0
- volcenginesdktidb/models/s3_for_list_import_tasks_output.py +201 -0
- volcenginesdktidb/models/s3_for_precheck_import_task_input.py +208 -0
- volcenginesdktidb/models/s3_for_validate_import_task_input.py +208 -0
- volcenginesdktidb/models/source_for_create_import_task_input.py +338 -0
- volcenginesdktidb/models/source_for_create_import_task_output.py +331 -0
- volcenginesdktidb/models/source_for_get_import_task_details_output.py +331 -0
- volcenginesdktidb/models/source_for_list_import_tasks_output.py +331 -0
- volcenginesdktidb/models/source_for_precheck_import_task_input.py +338 -0
- volcenginesdktidb/models/source_for_validate_import_task_input.py +338 -0
- volcenginesdktidb/models/spending_limit_for_restore_cluster_input.py +123 -0
- volcenginesdktidb/models/table_for_cancel_export_task_output.py +149 -0
- volcenginesdktidb/models/table_for_create_export_task_input.py +149 -0
- volcenginesdktidb/models/table_for_create_export_task_output.py +149 -0
- volcenginesdktidb/models/table_for_delete_export_task_output.py +149 -0
- volcenginesdktidb/models/table_for_get_export_task_details_output.py +149 -0
- volcenginesdktidb/models/table_for_get_import_table_columns_output.py +279 -0
- volcenginesdktidb/models/table_for_list_export_tasks_output.py +149 -0
- volcenginesdktidb/models/table_for_preview_local_import_output.py +279 -0
- volcenginesdktidb/models/target_for_cancel_export_task_output.py +253 -0
- volcenginesdktidb/models/target_for_create_export_task_input.py +260 -0
- volcenginesdktidb/models/target_for_create_export_task_output.py +253 -0
- volcenginesdktidb/models/target_for_delete_export_task_output.py +253 -0
- volcenginesdktidb/models/target_for_get_export_task_details_output.py +253 -0
- volcenginesdktidb/models/target_for_list_export_tasks_output.py +253 -0
- volcenginesdktidb/models/target_table_for_create_import_task_input.py +149 -0
- volcenginesdktidb/models/target_table_for_create_import_task_output.py +149 -0
- volcenginesdktidb/models/target_table_for_get_import_task_details_output.py +149 -0
- volcenginesdktidb/models/target_table_for_list_import_tasks_output.py +149 -0
- volcenginesdktidb/models/target_table_for_precheck_import_task_input.py +149 -0
- volcenginesdktidb/models/target_table_for_precheck_import_task_output.py +149 -0
- volcenginesdktidb/models/target_table_for_validate_import_task_input.py +149 -0
- volcenginesdktidb/models/target_table_info_for_create_import_task_input.py +149 -0
- volcenginesdktidb/models/target_table_info_for_create_import_task_output.py +149 -0
- volcenginesdktidb/models/target_table_info_for_get_import_task_details_output.py +149 -0
- volcenginesdktidb/models/target_table_info_for_list_import_tasks_output.py +149 -0
- volcenginesdktidb/models/target_table_info_for_precheck_import_task_input.py +149 -0
- volcenginesdktidb/models/target_table_info_for_validate_import_task_input.py +149 -0
- volcenginesdktidb/models/tos_for_cancel_export_task_output.py +175 -0
- volcenginesdktidb/models/tos_for_create_export_task_input.py +182 -0
- volcenginesdktidb/models/tos_for_create_export_task_output.py +175 -0
- volcenginesdktidb/models/tos_for_create_import_task_input.py +182 -0
- volcenginesdktidb/models/tos_for_create_import_task_output.py +175 -0
- volcenginesdktidb/models/tos_for_delete_export_task_output.py +175 -0
- volcenginesdktidb/models/tos_for_get_export_task_details_output.py +175 -0
- volcenginesdktidb/models/tos_for_get_import_task_details_output.py +175 -0
- volcenginesdktidb/models/tos_for_list_export_tasks_output.py +175 -0
- volcenginesdktidb/models/tos_for_list_import_tasks_output.py +175 -0
- volcenginesdktidb/models/tos_for_precheck_import_task_input.py +182 -0
- volcenginesdktidb/models/tos_for_validate_import_task_input.py +182 -0
- volcenginesdktidb/models/validate_import_task_request.py +210 -0
- volcenginesdktidb/models/validate_import_task_response.py +95 -0
- volcenginesdktidb/models/zone_for_list_zones_output.py +175 -0
- volcenginesdktidb/models/zone_for_restore_cluster_input.py +149 -0
- {volcengine_python_sdk-5.0.44.dist-info → volcengine_python_sdk-5.0.45.dist-info}/licenses/LICENSE.txt +0 -0
- {volcengine_python_sdk-5.0.44.dist-info → volcengine_python_sdk-5.0.45.dist-info}/licenses/NOTICE.md +0 -0
|
@@ -0,0 +1,3138 @@
|
|
|
1
|
+
# coding: utf-8
|
|
2
|
+
|
|
3
|
+
"""
|
|
4
|
+
tidb
|
|
5
|
+
|
|
6
|
+
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501
|
|
7
|
+
|
|
8
|
+
OpenAPI spec version: common-version
|
|
9
|
+
|
|
10
|
+
Generated by: https://github.com/swagger-api/swagger-codegen.git
|
|
11
|
+
"""
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
from __future__ import absolute_import
|
|
15
|
+
|
|
16
|
+
import re # noqa: F401
|
|
17
|
+
|
|
18
|
+
# python 2 and python 3 compatibility library
|
|
19
|
+
import six
|
|
20
|
+
|
|
21
|
+
import volcenginesdkcore
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
class TIDBApi(object):
|
|
25
|
+
"""NOTE: This class is auto generated by the swagger code generator program.
|
|
26
|
+
|
|
27
|
+
Do not edit the class manually.
|
|
28
|
+
Ref: https://github.com/swagger-api/swagger-codegen
|
|
29
|
+
"""
|
|
30
|
+
|
|
31
|
+
def __init__(self, api_client=None):
|
|
32
|
+
if api_client is None:
|
|
33
|
+
api_client = volcenginesdkcore.ApiClient()
|
|
34
|
+
self.api_client = api_client
|
|
35
|
+
|
|
36
|
+
def cancel_export_task(self, body, **kwargs): # noqa: E501
|
|
37
|
+
"""cancel_export_task # noqa: E501
|
|
38
|
+
|
|
39
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
40
|
+
asynchronous HTTP request, please pass async_req=True
|
|
41
|
+
>>> thread = api.cancel_export_task(body, async_req=True)
|
|
42
|
+
>>> result = thread.get()
|
|
43
|
+
|
|
44
|
+
:param async_req bool
|
|
45
|
+
:param CancelExportTaskRequest body: (required)
|
|
46
|
+
:return: CancelExportTaskResponse
|
|
47
|
+
If the method is called asynchronously,
|
|
48
|
+
returns the request thread.
|
|
49
|
+
"""
|
|
50
|
+
kwargs['_return_http_data_only'] = True
|
|
51
|
+
if kwargs.get('async_req'):
|
|
52
|
+
return self.cancel_export_task_with_http_info(body, **kwargs) # noqa: E501
|
|
53
|
+
else:
|
|
54
|
+
(data) = self.cancel_export_task_with_http_info(body, **kwargs) # noqa: E501
|
|
55
|
+
return data
|
|
56
|
+
|
|
57
|
+
def cancel_export_task_with_http_info(self, body, **kwargs): # noqa: E501
|
|
58
|
+
"""cancel_export_task # noqa: E501
|
|
59
|
+
|
|
60
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
61
|
+
asynchronous HTTP request, please pass async_req=True
|
|
62
|
+
>>> thread = api.cancel_export_task_with_http_info(body, async_req=True)
|
|
63
|
+
>>> result = thread.get()
|
|
64
|
+
|
|
65
|
+
:param async_req bool
|
|
66
|
+
:param CancelExportTaskRequest body: (required)
|
|
67
|
+
:return: CancelExportTaskResponse
|
|
68
|
+
If the method is called asynchronously,
|
|
69
|
+
returns the request thread.
|
|
70
|
+
"""
|
|
71
|
+
|
|
72
|
+
all_params = ['body'] # noqa: E501
|
|
73
|
+
all_params.append('async_req')
|
|
74
|
+
all_params.append('_return_http_data_only')
|
|
75
|
+
all_params.append('_preload_content')
|
|
76
|
+
all_params.append('_request_timeout')
|
|
77
|
+
|
|
78
|
+
params = locals()
|
|
79
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
80
|
+
if key not in all_params:
|
|
81
|
+
raise TypeError(
|
|
82
|
+
"Got an unexpected keyword argument '%s'"
|
|
83
|
+
" to method cancel_export_task" % key
|
|
84
|
+
)
|
|
85
|
+
params[key] = val
|
|
86
|
+
del params['kwargs']
|
|
87
|
+
# verify the required parameter 'body' is set
|
|
88
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
89
|
+
params['body'] is None): # noqa: E501
|
|
90
|
+
raise ValueError("Missing the required parameter `body` when calling `cancel_export_task`") # noqa: E501
|
|
91
|
+
|
|
92
|
+
collection_formats = {}
|
|
93
|
+
|
|
94
|
+
path_params = {}
|
|
95
|
+
|
|
96
|
+
query_params = []
|
|
97
|
+
|
|
98
|
+
header_params = {}
|
|
99
|
+
|
|
100
|
+
form_params = []
|
|
101
|
+
local_var_files = {}
|
|
102
|
+
|
|
103
|
+
body_params = None
|
|
104
|
+
if 'body' in params:
|
|
105
|
+
body_params = params['body']
|
|
106
|
+
# HTTP header `Accept`
|
|
107
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
108
|
+
['application/json']) # noqa: E501
|
|
109
|
+
|
|
110
|
+
# HTTP header `Content-Type`
|
|
111
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
112
|
+
['application/json']) # noqa: E501
|
|
113
|
+
|
|
114
|
+
# Authentication setting
|
|
115
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
116
|
+
|
|
117
|
+
return self.api_client.call_api(
|
|
118
|
+
'/CancelExportTask/2026-06-30/tidb/post/application_json/', 'POST',
|
|
119
|
+
path_params,
|
|
120
|
+
query_params,
|
|
121
|
+
header_params,
|
|
122
|
+
body=body_params,
|
|
123
|
+
post_params=form_params,
|
|
124
|
+
files=local_var_files,
|
|
125
|
+
response_type='CancelExportTaskResponse', # noqa: E501
|
|
126
|
+
auth_settings=auth_settings,
|
|
127
|
+
async_req=params.get('async_req'),
|
|
128
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
129
|
+
_preload_content=params.get('_preload_content', True),
|
|
130
|
+
_request_timeout=params.get('_request_timeout'),
|
|
131
|
+
collection_formats=collection_formats)
|
|
132
|
+
|
|
133
|
+
def cancel_import_task(self, body, **kwargs): # noqa: E501
|
|
134
|
+
"""cancel_import_task # noqa: E501
|
|
135
|
+
|
|
136
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
137
|
+
asynchronous HTTP request, please pass async_req=True
|
|
138
|
+
>>> thread = api.cancel_import_task(body, async_req=True)
|
|
139
|
+
>>> result = thread.get()
|
|
140
|
+
|
|
141
|
+
:param async_req bool
|
|
142
|
+
:param CancelImportTaskRequest body: (required)
|
|
143
|
+
:return: CancelImportTaskResponse
|
|
144
|
+
If the method is called asynchronously,
|
|
145
|
+
returns the request thread.
|
|
146
|
+
"""
|
|
147
|
+
kwargs['_return_http_data_only'] = True
|
|
148
|
+
if kwargs.get('async_req'):
|
|
149
|
+
return self.cancel_import_task_with_http_info(body, **kwargs) # noqa: E501
|
|
150
|
+
else:
|
|
151
|
+
(data) = self.cancel_import_task_with_http_info(body, **kwargs) # noqa: E501
|
|
152
|
+
return data
|
|
153
|
+
|
|
154
|
+
def cancel_import_task_with_http_info(self, body, **kwargs): # noqa: E501
|
|
155
|
+
"""cancel_import_task # noqa: E501
|
|
156
|
+
|
|
157
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
158
|
+
asynchronous HTTP request, please pass async_req=True
|
|
159
|
+
>>> thread = api.cancel_import_task_with_http_info(body, async_req=True)
|
|
160
|
+
>>> result = thread.get()
|
|
161
|
+
|
|
162
|
+
:param async_req bool
|
|
163
|
+
:param CancelImportTaskRequest body: (required)
|
|
164
|
+
:return: CancelImportTaskResponse
|
|
165
|
+
If the method is called asynchronously,
|
|
166
|
+
returns the request thread.
|
|
167
|
+
"""
|
|
168
|
+
|
|
169
|
+
all_params = ['body'] # noqa: E501
|
|
170
|
+
all_params.append('async_req')
|
|
171
|
+
all_params.append('_return_http_data_only')
|
|
172
|
+
all_params.append('_preload_content')
|
|
173
|
+
all_params.append('_request_timeout')
|
|
174
|
+
|
|
175
|
+
params = locals()
|
|
176
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
177
|
+
if key not in all_params:
|
|
178
|
+
raise TypeError(
|
|
179
|
+
"Got an unexpected keyword argument '%s'"
|
|
180
|
+
" to method cancel_import_task" % key
|
|
181
|
+
)
|
|
182
|
+
params[key] = val
|
|
183
|
+
del params['kwargs']
|
|
184
|
+
# verify the required parameter 'body' is set
|
|
185
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
186
|
+
params['body'] is None): # noqa: E501
|
|
187
|
+
raise ValueError("Missing the required parameter `body` when calling `cancel_import_task`") # noqa: E501
|
|
188
|
+
|
|
189
|
+
collection_formats = {}
|
|
190
|
+
|
|
191
|
+
path_params = {}
|
|
192
|
+
|
|
193
|
+
query_params = []
|
|
194
|
+
|
|
195
|
+
header_params = {}
|
|
196
|
+
|
|
197
|
+
form_params = []
|
|
198
|
+
local_var_files = {}
|
|
199
|
+
|
|
200
|
+
body_params = None
|
|
201
|
+
if 'body' in params:
|
|
202
|
+
body_params = params['body']
|
|
203
|
+
# HTTP header `Accept`
|
|
204
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
205
|
+
['application/json']) # noqa: E501
|
|
206
|
+
|
|
207
|
+
# HTTP header `Content-Type`
|
|
208
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
209
|
+
['application/json']) # noqa: E501
|
|
210
|
+
|
|
211
|
+
# Authentication setting
|
|
212
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
213
|
+
|
|
214
|
+
return self.api_client.call_api(
|
|
215
|
+
'/CancelImportTask/2026-06-30/tidb/post/application_json/', 'POST',
|
|
216
|
+
path_params,
|
|
217
|
+
query_params,
|
|
218
|
+
header_params,
|
|
219
|
+
body=body_params,
|
|
220
|
+
post_params=form_params,
|
|
221
|
+
files=local_var_files,
|
|
222
|
+
response_type='CancelImportTaskResponse', # noqa: E501
|
|
223
|
+
auth_settings=auth_settings,
|
|
224
|
+
async_req=params.get('async_req'),
|
|
225
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
226
|
+
_preload_content=params.get('_preload_content', True),
|
|
227
|
+
_request_timeout=params.get('_request_timeout'),
|
|
228
|
+
collection_formats=collection_formats)
|
|
229
|
+
|
|
230
|
+
def create_export_task(self, body, **kwargs): # noqa: E501
|
|
231
|
+
"""create_export_task # noqa: E501
|
|
232
|
+
|
|
233
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
234
|
+
asynchronous HTTP request, please pass async_req=True
|
|
235
|
+
>>> thread = api.create_export_task(body, async_req=True)
|
|
236
|
+
>>> result = thread.get()
|
|
237
|
+
|
|
238
|
+
:param async_req bool
|
|
239
|
+
:param CreateExportTaskRequest body: (required)
|
|
240
|
+
:return: CreateExportTaskResponse
|
|
241
|
+
If the method is called asynchronously,
|
|
242
|
+
returns the request thread.
|
|
243
|
+
"""
|
|
244
|
+
kwargs['_return_http_data_only'] = True
|
|
245
|
+
if kwargs.get('async_req'):
|
|
246
|
+
return self.create_export_task_with_http_info(body, **kwargs) # noqa: E501
|
|
247
|
+
else:
|
|
248
|
+
(data) = self.create_export_task_with_http_info(body, **kwargs) # noqa: E501
|
|
249
|
+
return data
|
|
250
|
+
|
|
251
|
+
def create_export_task_with_http_info(self, body, **kwargs): # noqa: E501
|
|
252
|
+
"""create_export_task # noqa: E501
|
|
253
|
+
|
|
254
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
255
|
+
asynchronous HTTP request, please pass async_req=True
|
|
256
|
+
>>> thread = api.create_export_task_with_http_info(body, async_req=True)
|
|
257
|
+
>>> result = thread.get()
|
|
258
|
+
|
|
259
|
+
:param async_req bool
|
|
260
|
+
:param CreateExportTaskRequest body: (required)
|
|
261
|
+
:return: CreateExportTaskResponse
|
|
262
|
+
If the method is called asynchronously,
|
|
263
|
+
returns the request thread.
|
|
264
|
+
"""
|
|
265
|
+
|
|
266
|
+
all_params = ['body'] # noqa: E501
|
|
267
|
+
all_params.append('async_req')
|
|
268
|
+
all_params.append('_return_http_data_only')
|
|
269
|
+
all_params.append('_preload_content')
|
|
270
|
+
all_params.append('_request_timeout')
|
|
271
|
+
|
|
272
|
+
params = locals()
|
|
273
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
274
|
+
if key not in all_params:
|
|
275
|
+
raise TypeError(
|
|
276
|
+
"Got an unexpected keyword argument '%s'"
|
|
277
|
+
" to method create_export_task" % key
|
|
278
|
+
)
|
|
279
|
+
params[key] = val
|
|
280
|
+
del params['kwargs']
|
|
281
|
+
# verify the required parameter 'body' is set
|
|
282
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
283
|
+
params['body'] is None): # noqa: E501
|
|
284
|
+
raise ValueError("Missing the required parameter `body` when calling `create_export_task`") # noqa: E501
|
|
285
|
+
|
|
286
|
+
collection_formats = {}
|
|
287
|
+
|
|
288
|
+
path_params = {}
|
|
289
|
+
|
|
290
|
+
query_params = []
|
|
291
|
+
|
|
292
|
+
header_params = {}
|
|
293
|
+
|
|
294
|
+
form_params = []
|
|
295
|
+
local_var_files = {}
|
|
296
|
+
|
|
297
|
+
body_params = None
|
|
298
|
+
if 'body' in params:
|
|
299
|
+
body_params = params['body']
|
|
300
|
+
# HTTP header `Accept`
|
|
301
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
302
|
+
['application/json']) # noqa: E501
|
|
303
|
+
|
|
304
|
+
# HTTP header `Content-Type`
|
|
305
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
306
|
+
['application/json']) # noqa: E501
|
|
307
|
+
|
|
308
|
+
# Authentication setting
|
|
309
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
310
|
+
|
|
311
|
+
return self.api_client.call_api(
|
|
312
|
+
'/CreateExportTask/2026-06-30/tidb/post/application_json/', 'POST',
|
|
313
|
+
path_params,
|
|
314
|
+
query_params,
|
|
315
|
+
header_params,
|
|
316
|
+
body=body_params,
|
|
317
|
+
post_params=form_params,
|
|
318
|
+
files=local_var_files,
|
|
319
|
+
response_type='CreateExportTaskResponse', # noqa: E501
|
|
320
|
+
auth_settings=auth_settings,
|
|
321
|
+
async_req=params.get('async_req'),
|
|
322
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
323
|
+
_preload_content=params.get('_preload_content', True),
|
|
324
|
+
_request_timeout=params.get('_request_timeout'),
|
|
325
|
+
collection_formats=collection_formats)
|
|
326
|
+
|
|
327
|
+
def create_import_task(self, body, **kwargs): # noqa: E501
|
|
328
|
+
"""create_import_task # noqa: E501
|
|
329
|
+
|
|
330
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
331
|
+
asynchronous HTTP request, please pass async_req=True
|
|
332
|
+
>>> thread = api.create_import_task(body, async_req=True)
|
|
333
|
+
>>> result = thread.get()
|
|
334
|
+
|
|
335
|
+
:param async_req bool
|
|
336
|
+
:param CreateImportTaskRequest body: (required)
|
|
337
|
+
:return: CreateImportTaskResponse
|
|
338
|
+
If the method is called asynchronously,
|
|
339
|
+
returns the request thread.
|
|
340
|
+
"""
|
|
341
|
+
kwargs['_return_http_data_only'] = True
|
|
342
|
+
if kwargs.get('async_req'):
|
|
343
|
+
return self.create_import_task_with_http_info(body, **kwargs) # noqa: E501
|
|
344
|
+
else:
|
|
345
|
+
(data) = self.create_import_task_with_http_info(body, **kwargs) # noqa: E501
|
|
346
|
+
return data
|
|
347
|
+
|
|
348
|
+
def create_import_task_with_http_info(self, body, **kwargs): # noqa: E501
|
|
349
|
+
"""create_import_task # noqa: E501
|
|
350
|
+
|
|
351
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
352
|
+
asynchronous HTTP request, please pass async_req=True
|
|
353
|
+
>>> thread = api.create_import_task_with_http_info(body, async_req=True)
|
|
354
|
+
>>> result = thread.get()
|
|
355
|
+
|
|
356
|
+
:param async_req bool
|
|
357
|
+
:param CreateImportTaskRequest body: (required)
|
|
358
|
+
:return: CreateImportTaskResponse
|
|
359
|
+
If the method is called asynchronously,
|
|
360
|
+
returns the request thread.
|
|
361
|
+
"""
|
|
362
|
+
|
|
363
|
+
all_params = ['body'] # noqa: E501
|
|
364
|
+
all_params.append('async_req')
|
|
365
|
+
all_params.append('_return_http_data_only')
|
|
366
|
+
all_params.append('_preload_content')
|
|
367
|
+
all_params.append('_request_timeout')
|
|
368
|
+
|
|
369
|
+
params = locals()
|
|
370
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
371
|
+
if key not in all_params:
|
|
372
|
+
raise TypeError(
|
|
373
|
+
"Got an unexpected keyword argument '%s'"
|
|
374
|
+
" to method create_import_task" % key
|
|
375
|
+
)
|
|
376
|
+
params[key] = val
|
|
377
|
+
del params['kwargs']
|
|
378
|
+
# verify the required parameter 'body' is set
|
|
379
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
380
|
+
params['body'] is None): # noqa: E501
|
|
381
|
+
raise ValueError("Missing the required parameter `body` when calling `create_import_task`") # noqa: E501
|
|
382
|
+
|
|
383
|
+
collection_formats = {}
|
|
384
|
+
|
|
385
|
+
path_params = {}
|
|
386
|
+
|
|
387
|
+
query_params = []
|
|
388
|
+
|
|
389
|
+
header_params = {}
|
|
390
|
+
|
|
391
|
+
form_params = []
|
|
392
|
+
local_var_files = {}
|
|
393
|
+
|
|
394
|
+
body_params = None
|
|
395
|
+
if 'body' in params:
|
|
396
|
+
body_params = params['body']
|
|
397
|
+
# HTTP header `Accept`
|
|
398
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
399
|
+
['application/json']) # noqa: E501
|
|
400
|
+
|
|
401
|
+
# HTTP header `Content-Type`
|
|
402
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
403
|
+
['application/json']) # noqa: E501
|
|
404
|
+
|
|
405
|
+
# Authentication setting
|
|
406
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
407
|
+
|
|
408
|
+
return self.api_client.call_api(
|
|
409
|
+
'/CreateImportTask/2026-06-30/tidb/post/application_json/', 'POST',
|
|
410
|
+
path_params,
|
|
411
|
+
query_params,
|
|
412
|
+
header_params,
|
|
413
|
+
body=body_params,
|
|
414
|
+
post_params=form_params,
|
|
415
|
+
files=local_var_files,
|
|
416
|
+
response_type='CreateImportTaskResponse', # noqa: E501
|
|
417
|
+
auth_settings=auth_settings,
|
|
418
|
+
async_req=params.get('async_req'),
|
|
419
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
420
|
+
_preload_content=params.get('_preload_content', True),
|
|
421
|
+
_request_timeout=params.get('_request_timeout'),
|
|
422
|
+
collection_formats=collection_formats)
|
|
423
|
+
|
|
424
|
+
def create_import_upload_url(self, body, **kwargs): # noqa: E501
|
|
425
|
+
"""create_import_upload_url # noqa: E501
|
|
426
|
+
|
|
427
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
428
|
+
asynchronous HTTP request, please pass async_req=True
|
|
429
|
+
>>> thread = api.create_import_upload_url(body, async_req=True)
|
|
430
|
+
>>> result = thread.get()
|
|
431
|
+
|
|
432
|
+
:param async_req bool
|
|
433
|
+
:param CreateImportUploadUrlRequest body: (required)
|
|
434
|
+
:return: CreateImportUploadUrlResponse
|
|
435
|
+
If the method is called asynchronously,
|
|
436
|
+
returns the request thread.
|
|
437
|
+
"""
|
|
438
|
+
kwargs['_return_http_data_only'] = True
|
|
439
|
+
if kwargs.get('async_req'):
|
|
440
|
+
return self.create_import_upload_url_with_http_info(body, **kwargs) # noqa: E501
|
|
441
|
+
else:
|
|
442
|
+
(data) = self.create_import_upload_url_with_http_info(body, **kwargs) # noqa: E501
|
|
443
|
+
return data
|
|
444
|
+
|
|
445
|
+
def create_import_upload_url_with_http_info(self, body, **kwargs): # noqa: E501
|
|
446
|
+
"""create_import_upload_url # noqa: E501
|
|
447
|
+
|
|
448
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
449
|
+
asynchronous HTTP request, please pass async_req=True
|
|
450
|
+
>>> thread = api.create_import_upload_url_with_http_info(body, async_req=True)
|
|
451
|
+
>>> result = thread.get()
|
|
452
|
+
|
|
453
|
+
:param async_req bool
|
|
454
|
+
:param CreateImportUploadUrlRequest body: (required)
|
|
455
|
+
:return: CreateImportUploadUrlResponse
|
|
456
|
+
If the method is called asynchronously,
|
|
457
|
+
returns the request thread.
|
|
458
|
+
"""
|
|
459
|
+
|
|
460
|
+
all_params = ['body'] # noqa: E501
|
|
461
|
+
all_params.append('async_req')
|
|
462
|
+
all_params.append('_return_http_data_only')
|
|
463
|
+
all_params.append('_preload_content')
|
|
464
|
+
all_params.append('_request_timeout')
|
|
465
|
+
|
|
466
|
+
params = locals()
|
|
467
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
468
|
+
if key not in all_params:
|
|
469
|
+
raise TypeError(
|
|
470
|
+
"Got an unexpected keyword argument '%s'"
|
|
471
|
+
" to method create_import_upload_url" % key
|
|
472
|
+
)
|
|
473
|
+
params[key] = val
|
|
474
|
+
del params['kwargs']
|
|
475
|
+
# verify the required parameter 'body' is set
|
|
476
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
477
|
+
params['body'] is None): # noqa: E501
|
|
478
|
+
raise ValueError("Missing the required parameter `body` when calling `create_import_upload_url`") # noqa: E501
|
|
479
|
+
|
|
480
|
+
collection_formats = {}
|
|
481
|
+
|
|
482
|
+
path_params = {}
|
|
483
|
+
|
|
484
|
+
query_params = []
|
|
485
|
+
|
|
486
|
+
header_params = {}
|
|
487
|
+
|
|
488
|
+
form_params = []
|
|
489
|
+
local_var_files = {}
|
|
490
|
+
|
|
491
|
+
body_params = None
|
|
492
|
+
if 'body' in params:
|
|
493
|
+
body_params = params['body']
|
|
494
|
+
# HTTP header `Accept`
|
|
495
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
496
|
+
['application/json']) # noqa: E501
|
|
497
|
+
|
|
498
|
+
# HTTP header `Content-Type`
|
|
499
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
500
|
+
['application/json']) # noqa: E501
|
|
501
|
+
|
|
502
|
+
# Authentication setting
|
|
503
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
504
|
+
|
|
505
|
+
return self.api_client.call_api(
|
|
506
|
+
'/CreateImportUploadUrl/2026-06-30/tidb/post/application_json/', 'POST',
|
|
507
|
+
path_params,
|
|
508
|
+
query_params,
|
|
509
|
+
header_params,
|
|
510
|
+
body=body_params,
|
|
511
|
+
post_params=form_params,
|
|
512
|
+
files=local_var_files,
|
|
513
|
+
response_type='CreateImportUploadUrlResponse', # noqa: E501
|
|
514
|
+
auth_settings=auth_settings,
|
|
515
|
+
async_req=params.get('async_req'),
|
|
516
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
517
|
+
_preload_content=params.get('_preload_content', True),
|
|
518
|
+
_request_timeout=params.get('_request_timeout'),
|
|
519
|
+
collection_formats=collection_formats)
|
|
520
|
+
|
|
521
|
+
def delete_export_task(self, body, **kwargs): # noqa: E501
|
|
522
|
+
"""delete_export_task # noqa: E501
|
|
523
|
+
|
|
524
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
525
|
+
asynchronous HTTP request, please pass async_req=True
|
|
526
|
+
>>> thread = api.delete_export_task(body, async_req=True)
|
|
527
|
+
>>> result = thread.get()
|
|
528
|
+
|
|
529
|
+
:param async_req bool
|
|
530
|
+
:param DeleteExportTaskRequest body: (required)
|
|
531
|
+
:return: DeleteExportTaskResponse
|
|
532
|
+
If the method is called asynchronously,
|
|
533
|
+
returns the request thread.
|
|
534
|
+
"""
|
|
535
|
+
kwargs['_return_http_data_only'] = True
|
|
536
|
+
if kwargs.get('async_req'):
|
|
537
|
+
return self.delete_export_task_with_http_info(body, **kwargs) # noqa: E501
|
|
538
|
+
else:
|
|
539
|
+
(data) = self.delete_export_task_with_http_info(body, **kwargs) # noqa: E501
|
|
540
|
+
return data
|
|
541
|
+
|
|
542
|
+
def delete_export_task_with_http_info(self, body, **kwargs): # noqa: E501
|
|
543
|
+
"""delete_export_task # noqa: E501
|
|
544
|
+
|
|
545
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
546
|
+
asynchronous HTTP request, please pass async_req=True
|
|
547
|
+
>>> thread = api.delete_export_task_with_http_info(body, async_req=True)
|
|
548
|
+
>>> result = thread.get()
|
|
549
|
+
|
|
550
|
+
:param async_req bool
|
|
551
|
+
:param DeleteExportTaskRequest body: (required)
|
|
552
|
+
:return: DeleteExportTaskResponse
|
|
553
|
+
If the method is called asynchronously,
|
|
554
|
+
returns the request thread.
|
|
555
|
+
"""
|
|
556
|
+
|
|
557
|
+
all_params = ['body'] # noqa: E501
|
|
558
|
+
all_params.append('async_req')
|
|
559
|
+
all_params.append('_return_http_data_only')
|
|
560
|
+
all_params.append('_preload_content')
|
|
561
|
+
all_params.append('_request_timeout')
|
|
562
|
+
|
|
563
|
+
params = locals()
|
|
564
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
565
|
+
if key not in all_params:
|
|
566
|
+
raise TypeError(
|
|
567
|
+
"Got an unexpected keyword argument '%s'"
|
|
568
|
+
" to method delete_export_task" % key
|
|
569
|
+
)
|
|
570
|
+
params[key] = val
|
|
571
|
+
del params['kwargs']
|
|
572
|
+
# verify the required parameter 'body' is set
|
|
573
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
574
|
+
params['body'] is None): # noqa: E501
|
|
575
|
+
raise ValueError("Missing the required parameter `body` when calling `delete_export_task`") # noqa: E501
|
|
576
|
+
|
|
577
|
+
collection_formats = {}
|
|
578
|
+
|
|
579
|
+
path_params = {}
|
|
580
|
+
|
|
581
|
+
query_params = []
|
|
582
|
+
|
|
583
|
+
header_params = {}
|
|
584
|
+
|
|
585
|
+
form_params = []
|
|
586
|
+
local_var_files = {}
|
|
587
|
+
|
|
588
|
+
body_params = None
|
|
589
|
+
if 'body' in params:
|
|
590
|
+
body_params = params['body']
|
|
591
|
+
# HTTP header `Accept`
|
|
592
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
593
|
+
['application/json']) # noqa: E501
|
|
594
|
+
|
|
595
|
+
# HTTP header `Content-Type`
|
|
596
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
597
|
+
['application/json']) # noqa: E501
|
|
598
|
+
|
|
599
|
+
# Authentication setting
|
|
600
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
601
|
+
|
|
602
|
+
return self.api_client.call_api(
|
|
603
|
+
'/DeleteExportTask/2026-06-30/tidb/post/application_json/', 'POST',
|
|
604
|
+
path_params,
|
|
605
|
+
query_params,
|
|
606
|
+
header_params,
|
|
607
|
+
body=body_params,
|
|
608
|
+
post_params=form_params,
|
|
609
|
+
files=local_var_files,
|
|
610
|
+
response_type='DeleteExportTaskResponse', # noqa: E501
|
|
611
|
+
auth_settings=auth_settings,
|
|
612
|
+
async_req=params.get('async_req'),
|
|
613
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
614
|
+
_preload_content=params.get('_preload_content', True),
|
|
615
|
+
_request_timeout=params.get('_request_timeout'),
|
|
616
|
+
collection_formats=collection_formats)
|
|
617
|
+
|
|
618
|
+
def get_backup(self, body, **kwargs): # noqa: E501
|
|
619
|
+
"""get_backup # noqa: E501
|
|
620
|
+
|
|
621
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
622
|
+
asynchronous HTTP request, please pass async_req=True
|
|
623
|
+
>>> thread = api.get_backup(body, async_req=True)
|
|
624
|
+
>>> result = thread.get()
|
|
625
|
+
|
|
626
|
+
:param async_req bool
|
|
627
|
+
:param GetBackupRequest body: (required)
|
|
628
|
+
:return: GetBackupResponse
|
|
629
|
+
If the method is called asynchronously,
|
|
630
|
+
returns the request thread.
|
|
631
|
+
"""
|
|
632
|
+
kwargs['_return_http_data_only'] = True
|
|
633
|
+
if kwargs.get('async_req'):
|
|
634
|
+
return self.get_backup_with_http_info(body, **kwargs) # noqa: E501
|
|
635
|
+
else:
|
|
636
|
+
(data) = self.get_backup_with_http_info(body, **kwargs) # noqa: E501
|
|
637
|
+
return data
|
|
638
|
+
|
|
639
|
+
def get_backup_with_http_info(self, body, **kwargs): # noqa: E501
|
|
640
|
+
"""get_backup # noqa: E501
|
|
641
|
+
|
|
642
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
643
|
+
asynchronous HTTP request, please pass async_req=True
|
|
644
|
+
>>> thread = api.get_backup_with_http_info(body, async_req=True)
|
|
645
|
+
>>> result = thread.get()
|
|
646
|
+
|
|
647
|
+
:param async_req bool
|
|
648
|
+
:param GetBackupRequest body: (required)
|
|
649
|
+
:return: GetBackupResponse
|
|
650
|
+
If the method is called asynchronously,
|
|
651
|
+
returns the request thread.
|
|
652
|
+
"""
|
|
653
|
+
|
|
654
|
+
all_params = ['body'] # noqa: E501
|
|
655
|
+
all_params.append('async_req')
|
|
656
|
+
all_params.append('_return_http_data_only')
|
|
657
|
+
all_params.append('_preload_content')
|
|
658
|
+
all_params.append('_request_timeout')
|
|
659
|
+
|
|
660
|
+
params = locals()
|
|
661
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
662
|
+
if key not in all_params:
|
|
663
|
+
raise TypeError(
|
|
664
|
+
"Got an unexpected keyword argument '%s'"
|
|
665
|
+
" to method get_backup" % key
|
|
666
|
+
)
|
|
667
|
+
params[key] = val
|
|
668
|
+
del params['kwargs']
|
|
669
|
+
# verify the required parameter 'body' is set
|
|
670
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
671
|
+
params['body'] is None): # noqa: E501
|
|
672
|
+
raise ValueError("Missing the required parameter `body` when calling `get_backup`") # noqa: E501
|
|
673
|
+
|
|
674
|
+
collection_formats = {}
|
|
675
|
+
|
|
676
|
+
path_params = {}
|
|
677
|
+
|
|
678
|
+
query_params = []
|
|
679
|
+
|
|
680
|
+
header_params = {}
|
|
681
|
+
|
|
682
|
+
form_params = []
|
|
683
|
+
local_var_files = {}
|
|
684
|
+
|
|
685
|
+
body_params = None
|
|
686
|
+
if 'body' in params:
|
|
687
|
+
body_params = params['body']
|
|
688
|
+
# HTTP header `Accept`
|
|
689
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
690
|
+
['application/json']) # noqa: E501
|
|
691
|
+
|
|
692
|
+
# HTTP header `Content-Type`
|
|
693
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
694
|
+
['application/json']) # noqa: E501
|
|
695
|
+
|
|
696
|
+
# Authentication setting
|
|
697
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
698
|
+
|
|
699
|
+
return self.api_client.call_api(
|
|
700
|
+
'/GetBackup/2026-06-30/tidb/post/application_json/', 'POST',
|
|
701
|
+
path_params,
|
|
702
|
+
query_params,
|
|
703
|
+
header_params,
|
|
704
|
+
body=body_params,
|
|
705
|
+
post_params=form_params,
|
|
706
|
+
files=local_var_files,
|
|
707
|
+
response_type='GetBackupResponse', # noqa: E501
|
|
708
|
+
auth_settings=auth_settings,
|
|
709
|
+
async_req=params.get('async_req'),
|
|
710
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
711
|
+
_preload_content=params.get('_preload_content', True),
|
|
712
|
+
_request_timeout=params.get('_request_timeout'),
|
|
713
|
+
collection_formats=collection_formats)
|
|
714
|
+
|
|
715
|
+
def get_backup_retention(self, body, **kwargs): # noqa: E501
|
|
716
|
+
"""get_backup_retention # noqa: E501
|
|
717
|
+
|
|
718
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
719
|
+
asynchronous HTTP request, please pass async_req=True
|
|
720
|
+
>>> thread = api.get_backup_retention(body, async_req=True)
|
|
721
|
+
>>> result = thread.get()
|
|
722
|
+
|
|
723
|
+
:param async_req bool
|
|
724
|
+
:param GetBackupRetentionRequest body: (required)
|
|
725
|
+
:return: GetBackupRetentionResponse
|
|
726
|
+
If the method is called asynchronously,
|
|
727
|
+
returns the request thread.
|
|
728
|
+
"""
|
|
729
|
+
kwargs['_return_http_data_only'] = True
|
|
730
|
+
if kwargs.get('async_req'):
|
|
731
|
+
return self.get_backup_retention_with_http_info(body, **kwargs) # noqa: E501
|
|
732
|
+
else:
|
|
733
|
+
(data) = self.get_backup_retention_with_http_info(body, **kwargs) # noqa: E501
|
|
734
|
+
return data
|
|
735
|
+
|
|
736
|
+
def get_backup_retention_with_http_info(self, body, **kwargs): # noqa: E501
|
|
737
|
+
"""get_backup_retention # noqa: E501
|
|
738
|
+
|
|
739
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
740
|
+
asynchronous HTTP request, please pass async_req=True
|
|
741
|
+
>>> thread = api.get_backup_retention_with_http_info(body, async_req=True)
|
|
742
|
+
>>> result = thread.get()
|
|
743
|
+
|
|
744
|
+
:param async_req bool
|
|
745
|
+
:param GetBackupRetentionRequest body: (required)
|
|
746
|
+
:return: GetBackupRetentionResponse
|
|
747
|
+
If the method is called asynchronously,
|
|
748
|
+
returns the request thread.
|
|
749
|
+
"""
|
|
750
|
+
|
|
751
|
+
all_params = ['body'] # noqa: E501
|
|
752
|
+
all_params.append('async_req')
|
|
753
|
+
all_params.append('_return_http_data_only')
|
|
754
|
+
all_params.append('_preload_content')
|
|
755
|
+
all_params.append('_request_timeout')
|
|
756
|
+
|
|
757
|
+
params = locals()
|
|
758
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
759
|
+
if key not in all_params:
|
|
760
|
+
raise TypeError(
|
|
761
|
+
"Got an unexpected keyword argument '%s'"
|
|
762
|
+
" to method get_backup_retention" % key
|
|
763
|
+
)
|
|
764
|
+
params[key] = val
|
|
765
|
+
del params['kwargs']
|
|
766
|
+
# verify the required parameter 'body' is set
|
|
767
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
768
|
+
params['body'] is None): # noqa: E501
|
|
769
|
+
raise ValueError("Missing the required parameter `body` when calling `get_backup_retention`") # noqa: E501
|
|
770
|
+
|
|
771
|
+
collection_formats = {}
|
|
772
|
+
|
|
773
|
+
path_params = {}
|
|
774
|
+
|
|
775
|
+
query_params = []
|
|
776
|
+
|
|
777
|
+
header_params = {}
|
|
778
|
+
|
|
779
|
+
form_params = []
|
|
780
|
+
local_var_files = {}
|
|
781
|
+
|
|
782
|
+
body_params = None
|
|
783
|
+
if 'body' in params:
|
|
784
|
+
body_params = params['body']
|
|
785
|
+
# HTTP header `Accept`
|
|
786
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
787
|
+
['application/json']) # noqa: E501
|
|
788
|
+
|
|
789
|
+
# HTTP header `Content-Type`
|
|
790
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
791
|
+
['application/json']) # noqa: E501
|
|
792
|
+
|
|
793
|
+
# Authentication setting
|
|
794
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
795
|
+
|
|
796
|
+
return self.api_client.call_api(
|
|
797
|
+
'/GetBackupRetention/2026-06-30/tidb/post/application_json/', 'POST',
|
|
798
|
+
path_params,
|
|
799
|
+
query_params,
|
|
800
|
+
header_params,
|
|
801
|
+
body=body_params,
|
|
802
|
+
post_params=form_params,
|
|
803
|
+
files=local_var_files,
|
|
804
|
+
response_type='GetBackupRetentionResponse', # noqa: E501
|
|
805
|
+
auth_settings=auth_settings,
|
|
806
|
+
async_req=params.get('async_req'),
|
|
807
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
808
|
+
_preload_content=params.get('_preload_content', True),
|
|
809
|
+
_request_timeout=params.get('_request_timeout'),
|
|
810
|
+
collection_formats=collection_formats)
|
|
811
|
+
|
|
812
|
+
def get_export_task_details(self, body, **kwargs): # noqa: E501
|
|
813
|
+
"""get_export_task_details # noqa: E501
|
|
814
|
+
|
|
815
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
816
|
+
asynchronous HTTP request, please pass async_req=True
|
|
817
|
+
>>> thread = api.get_export_task_details(body, async_req=True)
|
|
818
|
+
>>> result = thread.get()
|
|
819
|
+
|
|
820
|
+
:param async_req bool
|
|
821
|
+
:param GetExportTaskDetailsRequest body: (required)
|
|
822
|
+
:return: GetExportTaskDetailsResponse
|
|
823
|
+
If the method is called asynchronously,
|
|
824
|
+
returns the request thread.
|
|
825
|
+
"""
|
|
826
|
+
kwargs['_return_http_data_only'] = True
|
|
827
|
+
if kwargs.get('async_req'):
|
|
828
|
+
return self.get_export_task_details_with_http_info(body, **kwargs) # noqa: E501
|
|
829
|
+
else:
|
|
830
|
+
(data) = self.get_export_task_details_with_http_info(body, **kwargs) # noqa: E501
|
|
831
|
+
return data
|
|
832
|
+
|
|
833
|
+
def get_export_task_details_with_http_info(self, body, **kwargs): # noqa: E501
|
|
834
|
+
"""get_export_task_details # noqa: E501
|
|
835
|
+
|
|
836
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
837
|
+
asynchronous HTTP request, please pass async_req=True
|
|
838
|
+
>>> thread = api.get_export_task_details_with_http_info(body, async_req=True)
|
|
839
|
+
>>> result = thread.get()
|
|
840
|
+
|
|
841
|
+
:param async_req bool
|
|
842
|
+
:param GetExportTaskDetailsRequest body: (required)
|
|
843
|
+
:return: GetExportTaskDetailsResponse
|
|
844
|
+
If the method is called asynchronously,
|
|
845
|
+
returns the request thread.
|
|
846
|
+
"""
|
|
847
|
+
|
|
848
|
+
all_params = ['body'] # noqa: E501
|
|
849
|
+
all_params.append('async_req')
|
|
850
|
+
all_params.append('_return_http_data_only')
|
|
851
|
+
all_params.append('_preload_content')
|
|
852
|
+
all_params.append('_request_timeout')
|
|
853
|
+
|
|
854
|
+
params = locals()
|
|
855
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
856
|
+
if key not in all_params:
|
|
857
|
+
raise TypeError(
|
|
858
|
+
"Got an unexpected keyword argument '%s'"
|
|
859
|
+
" to method get_export_task_details" % key
|
|
860
|
+
)
|
|
861
|
+
params[key] = val
|
|
862
|
+
del params['kwargs']
|
|
863
|
+
# verify the required parameter 'body' is set
|
|
864
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
865
|
+
params['body'] is None): # noqa: E501
|
|
866
|
+
raise ValueError("Missing the required parameter `body` when calling `get_export_task_details`") # noqa: E501
|
|
867
|
+
|
|
868
|
+
collection_formats = {}
|
|
869
|
+
|
|
870
|
+
path_params = {}
|
|
871
|
+
|
|
872
|
+
query_params = []
|
|
873
|
+
|
|
874
|
+
header_params = {}
|
|
875
|
+
|
|
876
|
+
form_params = []
|
|
877
|
+
local_var_files = {}
|
|
878
|
+
|
|
879
|
+
body_params = None
|
|
880
|
+
if 'body' in params:
|
|
881
|
+
body_params = params['body']
|
|
882
|
+
# HTTP header `Accept`
|
|
883
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
884
|
+
['application/json']) # noqa: E501
|
|
885
|
+
|
|
886
|
+
# HTTP header `Content-Type`
|
|
887
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
888
|
+
['application/json']) # noqa: E501
|
|
889
|
+
|
|
890
|
+
# Authentication setting
|
|
891
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
892
|
+
|
|
893
|
+
return self.api_client.call_api(
|
|
894
|
+
'/GetExportTaskDetails/2026-06-30/tidb/post/application_json/', 'POST',
|
|
895
|
+
path_params,
|
|
896
|
+
query_params,
|
|
897
|
+
header_params,
|
|
898
|
+
body=body_params,
|
|
899
|
+
post_params=form_params,
|
|
900
|
+
files=local_var_files,
|
|
901
|
+
response_type='GetExportTaskDetailsResponse', # noqa: E501
|
|
902
|
+
auth_settings=auth_settings,
|
|
903
|
+
async_req=params.get('async_req'),
|
|
904
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
905
|
+
_preload_content=params.get('_preload_content', True),
|
|
906
|
+
_request_timeout=params.get('_request_timeout'),
|
|
907
|
+
collection_formats=collection_formats)
|
|
908
|
+
|
|
909
|
+
def get_import_table_columns(self, body, **kwargs): # noqa: E501
|
|
910
|
+
"""get_import_table_columns # noqa: E501
|
|
911
|
+
|
|
912
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
913
|
+
asynchronous HTTP request, please pass async_req=True
|
|
914
|
+
>>> thread = api.get_import_table_columns(body, async_req=True)
|
|
915
|
+
>>> result = thread.get()
|
|
916
|
+
|
|
917
|
+
:param async_req bool
|
|
918
|
+
:param GetImportTableColumnsRequest body: (required)
|
|
919
|
+
:return: GetImportTableColumnsResponse
|
|
920
|
+
If the method is called asynchronously,
|
|
921
|
+
returns the request thread.
|
|
922
|
+
"""
|
|
923
|
+
kwargs['_return_http_data_only'] = True
|
|
924
|
+
if kwargs.get('async_req'):
|
|
925
|
+
return self.get_import_table_columns_with_http_info(body, **kwargs) # noqa: E501
|
|
926
|
+
else:
|
|
927
|
+
(data) = self.get_import_table_columns_with_http_info(body, **kwargs) # noqa: E501
|
|
928
|
+
return data
|
|
929
|
+
|
|
930
|
+
def get_import_table_columns_with_http_info(self, body, **kwargs): # noqa: E501
|
|
931
|
+
"""get_import_table_columns # noqa: E501
|
|
932
|
+
|
|
933
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
934
|
+
asynchronous HTTP request, please pass async_req=True
|
|
935
|
+
>>> thread = api.get_import_table_columns_with_http_info(body, async_req=True)
|
|
936
|
+
>>> result = thread.get()
|
|
937
|
+
|
|
938
|
+
:param async_req bool
|
|
939
|
+
:param GetImportTableColumnsRequest body: (required)
|
|
940
|
+
:return: GetImportTableColumnsResponse
|
|
941
|
+
If the method is called asynchronously,
|
|
942
|
+
returns the request thread.
|
|
943
|
+
"""
|
|
944
|
+
|
|
945
|
+
all_params = ['body'] # noqa: E501
|
|
946
|
+
all_params.append('async_req')
|
|
947
|
+
all_params.append('_return_http_data_only')
|
|
948
|
+
all_params.append('_preload_content')
|
|
949
|
+
all_params.append('_request_timeout')
|
|
950
|
+
|
|
951
|
+
params = locals()
|
|
952
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
953
|
+
if key not in all_params:
|
|
954
|
+
raise TypeError(
|
|
955
|
+
"Got an unexpected keyword argument '%s'"
|
|
956
|
+
" to method get_import_table_columns" % key
|
|
957
|
+
)
|
|
958
|
+
params[key] = val
|
|
959
|
+
del params['kwargs']
|
|
960
|
+
# verify the required parameter 'body' is set
|
|
961
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
962
|
+
params['body'] is None): # noqa: E501
|
|
963
|
+
raise ValueError("Missing the required parameter `body` when calling `get_import_table_columns`") # noqa: E501
|
|
964
|
+
|
|
965
|
+
collection_formats = {}
|
|
966
|
+
|
|
967
|
+
path_params = {}
|
|
968
|
+
|
|
969
|
+
query_params = []
|
|
970
|
+
|
|
971
|
+
header_params = {}
|
|
972
|
+
|
|
973
|
+
form_params = []
|
|
974
|
+
local_var_files = {}
|
|
975
|
+
|
|
976
|
+
body_params = None
|
|
977
|
+
if 'body' in params:
|
|
978
|
+
body_params = params['body']
|
|
979
|
+
# HTTP header `Accept`
|
|
980
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
981
|
+
['application/json']) # noqa: E501
|
|
982
|
+
|
|
983
|
+
# HTTP header `Content-Type`
|
|
984
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
985
|
+
['application/json']) # noqa: E501
|
|
986
|
+
|
|
987
|
+
# Authentication setting
|
|
988
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
989
|
+
|
|
990
|
+
return self.api_client.call_api(
|
|
991
|
+
'/GetImportTableColumns/2026-06-30/tidb/post/application_json/', 'POST',
|
|
992
|
+
path_params,
|
|
993
|
+
query_params,
|
|
994
|
+
header_params,
|
|
995
|
+
body=body_params,
|
|
996
|
+
post_params=form_params,
|
|
997
|
+
files=local_var_files,
|
|
998
|
+
response_type='GetImportTableColumnsResponse', # noqa: E501
|
|
999
|
+
auth_settings=auth_settings,
|
|
1000
|
+
async_req=params.get('async_req'),
|
|
1001
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1002
|
+
_preload_content=params.get('_preload_content', True),
|
|
1003
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1004
|
+
collection_formats=collection_formats)
|
|
1005
|
+
|
|
1006
|
+
def get_import_task_details(self, body, **kwargs): # noqa: E501
|
|
1007
|
+
"""get_import_task_details # noqa: E501
|
|
1008
|
+
|
|
1009
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1010
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1011
|
+
>>> thread = api.get_import_task_details(body, async_req=True)
|
|
1012
|
+
>>> result = thread.get()
|
|
1013
|
+
|
|
1014
|
+
:param async_req bool
|
|
1015
|
+
:param GetImportTaskDetailsRequest body: (required)
|
|
1016
|
+
:return: GetImportTaskDetailsResponse
|
|
1017
|
+
If the method is called asynchronously,
|
|
1018
|
+
returns the request thread.
|
|
1019
|
+
"""
|
|
1020
|
+
kwargs['_return_http_data_only'] = True
|
|
1021
|
+
if kwargs.get('async_req'):
|
|
1022
|
+
return self.get_import_task_details_with_http_info(body, **kwargs) # noqa: E501
|
|
1023
|
+
else:
|
|
1024
|
+
(data) = self.get_import_task_details_with_http_info(body, **kwargs) # noqa: E501
|
|
1025
|
+
return data
|
|
1026
|
+
|
|
1027
|
+
def get_import_task_details_with_http_info(self, body, **kwargs): # noqa: E501
|
|
1028
|
+
"""get_import_task_details # noqa: E501
|
|
1029
|
+
|
|
1030
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1031
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1032
|
+
>>> thread = api.get_import_task_details_with_http_info(body, async_req=True)
|
|
1033
|
+
>>> result = thread.get()
|
|
1034
|
+
|
|
1035
|
+
:param async_req bool
|
|
1036
|
+
:param GetImportTaskDetailsRequest body: (required)
|
|
1037
|
+
:return: GetImportTaskDetailsResponse
|
|
1038
|
+
If the method is called asynchronously,
|
|
1039
|
+
returns the request thread.
|
|
1040
|
+
"""
|
|
1041
|
+
|
|
1042
|
+
all_params = ['body'] # noqa: E501
|
|
1043
|
+
all_params.append('async_req')
|
|
1044
|
+
all_params.append('_return_http_data_only')
|
|
1045
|
+
all_params.append('_preload_content')
|
|
1046
|
+
all_params.append('_request_timeout')
|
|
1047
|
+
|
|
1048
|
+
params = locals()
|
|
1049
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
1050
|
+
if key not in all_params:
|
|
1051
|
+
raise TypeError(
|
|
1052
|
+
"Got an unexpected keyword argument '%s'"
|
|
1053
|
+
" to method get_import_task_details" % key
|
|
1054
|
+
)
|
|
1055
|
+
params[key] = val
|
|
1056
|
+
del params['kwargs']
|
|
1057
|
+
# verify the required parameter 'body' is set
|
|
1058
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
1059
|
+
params['body'] is None): # noqa: E501
|
|
1060
|
+
raise ValueError("Missing the required parameter `body` when calling `get_import_task_details`") # noqa: E501
|
|
1061
|
+
|
|
1062
|
+
collection_formats = {}
|
|
1063
|
+
|
|
1064
|
+
path_params = {}
|
|
1065
|
+
|
|
1066
|
+
query_params = []
|
|
1067
|
+
|
|
1068
|
+
header_params = {}
|
|
1069
|
+
|
|
1070
|
+
form_params = []
|
|
1071
|
+
local_var_files = {}
|
|
1072
|
+
|
|
1073
|
+
body_params = None
|
|
1074
|
+
if 'body' in params:
|
|
1075
|
+
body_params = params['body']
|
|
1076
|
+
# HTTP header `Accept`
|
|
1077
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
1078
|
+
['application/json']) # noqa: E501
|
|
1079
|
+
|
|
1080
|
+
# HTTP header `Content-Type`
|
|
1081
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
1082
|
+
['application/json']) # noqa: E501
|
|
1083
|
+
|
|
1084
|
+
# Authentication setting
|
|
1085
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
1086
|
+
|
|
1087
|
+
return self.api_client.call_api(
|
|
1088
|
+
'/GetImportTaskDetails/2026-06-30/tidb/post/application_json/', 'POST',
|
|
1089
|
+
path_params,
|
|
1090
|
+
query_params,
|
|
1091
|
+
header_params,
|
|
1092
|
+
body=body_params,
|
|
1093
|
+
post_params=form_params,
|
|
1094
|
+
files=local_var_files,
|
|
1095
|
+
response_type='GetImportTaskDetailsResponse', # noqa: E501
|
|
1096
|
+
auth_settings=auth_settings,
|
|
1097
|
+
async_req=params.get('async_req'),
|
|
1098
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1099
|
+
_preload_content=params.get('_preload_content', True),
|
|
1100
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1101
|
+
collection_formats=collection_formats)
|
|
1102
|
+
|
|
1103
|
+
def get_metrics(self, body, **kwargs): # noqa: E501
|
|
1104
|
+
"""get_metrics # noqa: E501
|
|
1105
|
+
|
|
1106
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1107
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1108
|
+
>>> thread = api.get_metrics(body, async_req=True)
|
|
1109
|
+
>>> result = thread.get()
|
|
1110
|
+
|
|
1111
|
+
:param async_req bool
|
|
1112
|
+
:param GetMetricsRequest body: (required)
|
|
1113
|
+
:return: GetMetricsResponse
|
|
1114
|
+
If the method is called asynchronously,
|
|
1115
|
+
returns the request thread.
|
|
1116
|
+
"""
|
|
1117
|
+
kwargs['_return_http_data_only'] = True
|
|
1118
|
+
if kwargs.get('async_req'):
|
|
1119
|
+
return self.get_metrics_with_http_info(body, **kwargs) # noqa: E501
|
|
1120
|
+
else:
|
|
1121
|
+
(data) = self.get_metrics_with_http_info(body, **kwargs) # noqa: E501
|
|
1122
|
+
return data
|
|
1123
|
+
|
|
1124
|
+
def get_metrics_with_http_info(self, body, **kwargs): # noqa: E501
|
|
1125
|
+
"""get_metrics # noqa: E501
|
|
1126
|
+
|
|
1127
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1128
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1129
|
+
>>> thread = api.get_metrics_with_http_info(body, async_req=True)
|
|
1130
|
+
>>> result = thread.get()
|
|
1131
|
+
|
|
1132
|
+
:param async_req bool
|
|
1133
|
+
:param GetMetricsRequest body: (required)
|
|
1134
|
+
:return: GetMetricsResponse
|
|
1135
|
+
If the method is called asynchronously,
|
|
1136
|
+
returns the request thread.
|
|
1137
|
+
"""
|
|
1138
|
+
|
|
1139
|
+
all_params = ['body'] # noqa: E501
|
|
1140
|
+
all_params.append('async_req')
|
|
1141
|
+
all_params.append('_return_http_data_only')
|
|
1142
|
+
all_params.append('_preload_content')
|
|
1143
|
+
all_params.append('_request_timeout')
|
|
1144
|
+
|
|
1145
|
+
params = locals()
|
|
1146
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
1147
|
+
if key not in all_params:
|
|
1148
|
+
raise TypeError(
|
|
1149
|
+
"Got an unexpected keyword argument '%s'"
|
|
1150
|
+
" to method get_metrics" % key
|
|
1151
|
+
)
|
|
1152
|
+
params[key] = val
|
|
1153
|
+
del params['kwargs']
|
|
1154
|
+
# verify the required parameter 'body' is set
|
|
1155
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
1156
|
+
params['body'] is None): # noqa: E501
|
|
1157
|
+
raise ValueError("Missing the required parameter `body` when calling `get_metrics`") # noqa: E501
|
|
1158
|
+
|
|
1159
|
+
collection_formats = {}
|
|
1160
|
+
|
|
1161
|
+
path_params = {}
|
|
1162
|
+
|
|
1163
|
+
query_params = []
|
|
1164
|
+
|
|
1165
|
+
header_params = {}
|
|
1166
|
+
|
|
1167
|
+
form_params = []
|
|
1168
|
+
local_var_files = {}
|
|
1169
|
+
|
|
1170
|
+
body_params = None
|
|
1171
|
+
if 'body' in params:
|
|
1172
|
+
body_params = params['body']
|
|
1173
|
+
# HTTP header `Accept`
|
|
1174
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
1175
|
+
['application/json']) # noqa: E501
|
|
1176
|
+
|
|
1177
|
+
# HTTP header `Content-Type`
|
|
1178
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
1179
|
+
['application/json']) # noqa: E501
|
|
1180
|
+
|
|
1181
|
+
# Authentication setting
|
|
1182
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
1183
|
+
|
|
1184
|
+
return self.api_client.call_api(
|
|
1185
|
+
'/GetMetrics/2026-06-30/tidb/post/application_json/', 'POST',
|
|
1186
|
+
path_params,
|
|
1187
|
+
query_params,
|
|
1188
|
+
header_params,
|
|
1189
|
+
body=body_params,
|
|
1190
|
+
post_params=form_params,
|
|
1191
|
+
files=local_var_files,
|
|
1192
|
+
response_type='GetMetricsResponse', # noqa: E501
|
|
1193
|
+
auth_settings=auth_settings,
|
|
1194
|
+
async_req=params.get('async_req'),
|
|
1195
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1196
|
+
_preload_content=params.get('_preload_content', True),
|
|
1197
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1198
|
+
collection_formats=collection_formats)
|
|
1199
|
+
|
|
1200
|
+
def get_restore_progress(self, body, **kwargs): # noqa: E501
|
|
1201
|
+
"""get_restore_progress # noqa: E501
|
|
1202
|
+
|
|
1203
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1204
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1205
|
+
>>> thread = api.get_restore_progress(body, async_req=True)
|
|
1206
|
+
>>> result = thread.get()
|
|
1207
|
+
|
|
1208
|
+
:param async_req bool
|
|
1209
|
+
:param GetRestoreProgressRequest body: (required)
|
|
1210
|
+
:return: GetRestoreProgressResponse
|
|
1211
|
+
If the method is called asynchronously,
|
|
1212
|
+
returns the request thread.
|
|
1213
|
+
"""
|
|
1214
|
+
kwargs['_return_http_data_only'] = True
|
|
1215
|
+
if kwargs.get('async_req'):
|
|
1216
|
+
return self.get_restore_progress_with_http_info(body, **kwargs) # noqa: E501
|
|
1217
|
+
else:
|
|
1218
|
+
(data) = self.get_restore_progress_with_http_info(body, **kwargs) # noqa: E501
|
|
1219
|
+
return data
|
|
1220
|
+
|
|
1221
|
+
def get_restore_progress_with_http_info(self, body, **kwargs): # noqa: E501
|
|
1222
|
+
"""get_restore_progress # noqa: E501
|
|
1223
|
+
|
|
1224
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1225
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1226
|
+
>>> thread = api.get_restore_progress_with_http_info(body, async_req=True)
|
|
1227
|
+
>>> result = thread.get()
|
|
1228
|
+
|
|
1229
|
+
:param async_req bool
|
|
1230
|
+
:param GetRestoreProgressRequest body: (required)
|
|
1231
|
+
:return: GetRestoreProgressResponse
|
|
1232
|
+
If the method is called asynchronously,
|
|
1233
|
+
returns the request thread.
|
|
1234
|
+
"""
|
|
1235
|
+
|
|
1236
|
+
all_params = ['body'] # noqa: E501
|
|
1237
|
+
all_params.append('async_req')
|
|
1238
|
+
all_params.append('_return_http_data_only')
|
|
1239
|
+
all_params.append('_preload_content')
|
|
1240
|
+
all_params.append('_request_timeout')
|
|
1241
|
+
|
|
1242
|
+
params = locals()
|
|
1243
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
1244
|
+
if key not in all_params:
|
|
1245
|
+
raise TypeError(
|
|
1246
|
+
"Got an unexpected keyword argument '%s'"
|
|
1247
|
+
" to method get_restore_progress" % key
|
|
1248
|
+
)
|
|
1249
|
+
params[key] = val
|
|
1250
|
+
del params['kwargs']
|
|
1251
|
+
# verify the required parameter 'body' is set
|
|
1252
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
1253
|
+
params['body'] is None): # noqa: E501
|
|
1254
|
+
raise ValueError("Missing the required parameter `body` when calling `get_restore_progress`") # noqa: E501
|
|
1255
|
+
|
|
1256
|
+
collection_formats = {}
|
|
1257
|
+
|
|
1258
|
+
path_params = {}
|
|
1259
|
+
|
|
1260
|
+
query_params = []
|
|
1261
|
+
|
|
1262
|
+
header_params = {}
|
|
1263
|
+
|
|
1264
|
+
form_params = []
|
|
1265
|
+
local_var_files = {}
|
|
1266
|
+
|
|
1267
|
+
body_params = None
|
|
1268
|
+
if 'body' in params:
|
|
1269
|
+
body_params = params['body']
|
|
1270
|
+
# HTTP header `Accept`
|
|
1271
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
1272
|
+
['application/json']) # noqa: E501
|
|
1273
|
+
|
|
1274
|
+
# HTTP header `Content-Type`
|
|
1275
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
1276
|
+
['application/json']) # noqa: E501
|
|
1277
|
+
|
|
1278
|
+
# Authentication setting
|
|
1279
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
1280
|
+
|
|
1281
|
+
return self.api_client.call_api(
|
|
1282
|
+
'/GetRestoreProgress/2026-06-30/tidb/post/application_json/', 'POST',
|
|
1283
|
+
path_params,
|
|
1284
|
+
query_params,
|
|
1285
|
+
header_params,
|
|
1286
|
+
body=body_params,
|
|
1287
|
+
post_params=form_params,
|
|
1288
|
+
files=local_var_files,
|
|
1289
|
+
response_type='GetRestoreProgressResponse', # noqa: E501
|
|
1290
|
+
auth_settings=auth_settings,
|
|
1291
|
+
async_req=params.get('async_req'),
|
|
1292
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1293
|
+
_preload_content=params.get('_preload_content', True),
|
|
1294
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1295
|
+
collection_formats=collection_formats)
|
|
1296
|
+
|
|
1297
|
+
def get_slow_query_details(self, body, **kwargs): # noqa: E501
|
|
1298
|
+
"""get_slow_query_details # noqa: E501
|
|
1299
|
+
|
|
1300
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1301
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1302
|
+
>>> thread = api.get_slow_query_details(body, async_req=True)
|
|
1303
|
+
>>> result = thread.get()
|
|
1304
|
+
|
|
1305
|
+
:param async_req bool
|
|
1306
|
+
:param GetSlowQueryDetailsRequest body: (required)
|
|
1307
|
+
:return: GetSlowQueryDetailsResponse
|
|
1308
|
+
If the method is called asynchronously,
|
|
1309
|
+
returns the request thread.
|
|
1310
|
+
"""
|
|
1311
|
+
kwargs['_return_http_data_only'] = True
|
|
1312
|
+
if kwargs.get('async_req'):
|
|
1313
|
+
return self.get_slow_query_details_with_http_info(body, **kwargs) # noqa: E501
|
|
1314
|
+
else:
|
|
1315
|
+
(data) = self.get_slow_query_details_with_http_info(body, **kwargs) # noqa: E501
|
|
1316
|
+
return data
|
|
1317
|
+
|
|
1318
|
+
def get_slow_query_details_with_http_info(self, body, **kwargs): # noqa: E501
|
|
1319
|
+
"""get_slow_query_details # noqa: E501
|
|
1320
|
+
|
|
1321
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1322
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1323
|
+
>>> thread = api.get_slow_query_details_with_http_info(body, async_req=True)
|
|
1324
|
+
>>> result = thread.get()
|
|
1325
|
+
|
|
1326
|
+
:param async_req bool
|
|
1327
|
+
:param GetSlowQueryDetailsRequest body: (required)
|
|
1328
|
+
:return: GetSlowQueryDetailsResponse
|
|
1329
|
+
If the method is called asynchronously,
|
|
1330
|
+
returns the request thread.
|
|
1331
|
+
"""
|
|
1332
|
+
|
|
1333
|
+
all_params = ['body'] # noqa: E501
|
|
1334
|
+
all_params.append('async_req')
|
|
1335
|
+
all_params.append('_return_http_data_only')
|
|
1336
|
+
all_params.append('_preload_content')
|
|
1337
|
+
all_params.append('_request_timeout')
|
|
1338
|
+
|
|
1339
|
+
params = locals()
|
|
1340
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
1341
|
+
if key not in all_params:
|
|
1342
|
+
raise TypeError(
|
|
1343
|
+
"Got an unexpected keyword argument '%s'"
|
|
1344
|
+
" to method get_slow_query_details" % key
|
|
1345
|
+
)
|
|
1346
|
+
params[key] = val
|
|
1347
|
+
del params['kwargs']
|
|
1348
|
+
# verify the required parameter 'body' is set
|
|
1349
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
1350
|
+
params['body'] is None): # noqa: E501
|
|
1351
|
+
raise ValueError("Missing the required parameter `body` when calling `get_slow_query_details`") # noqa: E501
|
|
1352
|
+
|
|
1353
|
+
collection_formats = {}
|
|
1354
|
+
|
|
1355
|
+
path_params = {}
|
|
1356
|
+
|
|
1357
|
+
query_params = []
|
|
1358
|
+
|
|
1359
|
+
header_params = {}
|
|
1360
|
+
|
|
1361
|
+
form_params = []
|
|
1362
|
+
local_var_files = {}
|
|
1363
|
+
|
|
1364
|
+
body_params = None
|
|
1365
|
+
if 'body' in params:
|
|
1366
|
+
body_params = params['body']
|
|
1367
|
+
# HTTP header `Accept`
|
|
1368
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
1369
|
+
['application/json']) # noqa: E501
|
|
1370
|
+
|
|
1371
|
+
# HTTP header `Content-Type`
|
|
1372
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
1373
|
+
['application/json']) # noqa: E501
|
|
1374
|
+
|
|
1375
|
+
# Authentication setting
|
|
1376
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
1377
|
+
|
|
1378
|
+
return self.api_client.call_api(
|
|
1379
|
+
'/GetSlowQueryDetails/2026-06-30/tidb/post/application_json/', 'POST',
|
|
1380
|
+
path_params,
|
|
1381
|
+
query_params,
|
|
1382
|
+
header_params,
|
|
1383
|
+
body=body_params,
|
|
1384
|
+
post_params=form_params,
|
|
1385
|
+
files=local_var_files,
|
|
1386
|
+
response_type='GetSlowQueryDetailsResponse', # noqa: E501
|
|
1387
|
+
auth_settings=auth_settings,
|
|
1388
|
+
async_req=params.get('async_req'),
|
|
1389
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1390
|
+
_preload_content=params.get('_preload_content', True),
|
|
1391
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1392
|
+
collection_formats=collection_formats)
|
|
1393
|
+
|
|
1394
|
+
def get_statement_plan_details(self, body, **kwargs): # noqa: E501
|
|
1395
|
+
"""get_statement_plan_details # noqa: E501
|
|
1396
|
+
|
|
1397
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1398
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1399
|
+
>>> thread = api.get_statement_plan_details(body, async_req=True)
|
|
1400
|
+
>>> result = thread.get()
|
|
1401
|
+
|
|
1402
|
+
:param async_req bool
|
|
1403
|
+
:param GetStatementPlanDetailsRequest body: (required)
|
|
1404
|
+
:return: GetStatementPlanDetailsResponse
|
|
1405
|
+
If the method is called asynchronously,
|
|
1406
|
+
returns the request thread.
|
|
1407
|
+
"""
|
|
1408
|
+
kwargs['_return_http_data_only'] = True
|
|
1409
|
+
if kwargs.get('async_req'):
|
|
1410
|
+
return self.get_statement_plan_details_with_http_info(body, **kwargs) # noqa: E501
|
|
1411
|
+
else:
|
|
1412
|
+
(data) = self.get_statement_plan_details_with_http_info(body, **kwargs) # noqa: E501
|
|
1413
|
+
return data
|
|
1414
|
+
|
|
1415
|
+
def get_statement_plan_details_with_http_info(self, body, **kwargs): # noqa: E501
|
|
1416
|
+
"""get_statement_plan_details # noqa: E501
|
|
1417
|
+
|
|
1418
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1419
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1420
|
+
>>> thread = api.get_statement_plan_details_with_http_info(body, async_req=True)
|
|
1421
|
+
>>> result = thread.get()
|
|
1422
|
+
|
|
1423
|
+
:param async_req bool
|
|
1424
|
+
:param GetStatementPlanDetailsRequest body: (required)
|
|
1425
|
+
:return: GetStatementPlanDetailsResponse
|
|
1426
|
+
If the method is called asynchronously,
|
|
1427
|
+
returns the request thread.
|
|
1428
|
+
"""
|
|
1429
|
+
|
|
1430
|
+
all_params = ['body'] # noqa: E501
|
|
1431
|
+
all_params.append('async_req')
|
|
1432
|
+
all_params.append('_return_http_data_only')
|
|
1433
|
+
all_params.append('_preload_content')
|
|
1434
|
+
all_params.append('_request_timeout')
|
|
1435
|
+
|
|
1436
|
+
params = locals()
|
|
1437
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
1438
|
+
if key not in all_params:
|
|
1439
|
+
raise TypeError(
|
|
1440
|
+
"Got an unexpected keyword argument '%s'"
|
|
1441
|
+
" to method get_statement_plan_details" % key
|
|
1442
|
+
)
|
|
1443
|
+
params[key] = val
|
|
1444
|
+
del params['kwargs']
|
|
1445
|
+
# verify the required parameter 'body' is set
|
|
1446
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
1447
|
+
params['body'] is None): # noqa: E501
|
|
1448
|
+
raise ValueError("Missing the required parameter `body` when calling `get_statement_plan_details`") # noqa: E501
|
|
1449
|
+
|
|
1450
|
+
collection_formats = {}
|
|
1451
|
+
|
|
1452
|
+
path_params = {}
|
|
1453
|
+
|
|
1454
|
+
query_params = []
|
|
1455
|
+
|
|
1456
|
+
header_params = {}
|
|
1457
|
+
|
|
1458
|
+
form_params = []
|
|
1459
|
+
local_var_files = {}
|
|
1460
|
+
|
|
1461
|
+
body_params = None
|
|
1462
|
+
if 'body' in params:
|
|
1463
|
+
body_params = params['body']
|
|
1464
|
+
# HTTP header `Accept`
|
|
1465
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
1466
|
+
['application/json']) # noqa: E501
|
|
1467
|
+
|
|
1468
|
+
# HTTP header `Content-Type`
|
|
1469
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
1470
|
+
['application/json']) # noqa: E501
|
|
1471
|
+
|
|
1472
|
+
# Authentication setting
|
|
1473
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
1474
|
+
|
|
1475
|
+
return self.api_client.call_api(
|
|
1476
|
+
'/GetStatementPlanDetails/2026-06-30/tidb/post/application_json/', 'POST',
|
|
1477
|
+
path_params,
|
|
1478
|
+
query_params,
|
|
1479
|
+
header_params,
|
|
1480
|
+
body=body_params,
|
|
1481
|
+
post_params=form_params,
|
|
1482
|
+
files=local_var_files,
|
|
1483
|
+
response_type='GetStatementPlanDetailsResponse', # noqa: E501
|
|
1484
|
+
auth_settings=auth_settings,
|
|
1485
|
+
async_req=params.get('async_req'),
|
|
1486
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1487
|
+
_preload_content=params.get('_preload_content', True),
|
|
1488
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1489
|
+
collection_formats=collection_formats)
|
|
1490
|
+
|
|
1491
|
+
def list_backups(self, body, **kwargs): # noqa: E501
|
|
1492
|
+
"""list_backups # noqa: E501
|
|
1493
|
+
|
|
1494
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1495
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1496
|
+
>>> thread = api.list_backups(body, async_req=True)
|
|
1497
|
+
>>> result = thread.get()
|
|
1498
|
+
|
|
1499
|
+
:param async_req bool
|
|
1500
|
+
:param ListBackupsRequest body: (required)
|
|
1501
|
+
:return: ListBackupsResponse
|
|
1502
|
+
If the method is called asynchronously,
|
|
1503
|
+
returns the request thread.
|
|
1504
|
+
"""
|
|
1505
|
+
kwargs['_return_http_data_only'] = True
|
|
1506
|
+
if kwargs.get('async_req'):
|
|
1507
|
+
return self.list_backups_with_http_info(body, **kwargs) # noqa: E501
|
|
1508
|
+
else:
|
|
1509
|
+
(data) = self.list_backups_with_http_info(body, **kwargs) # noqa: E501
|
|
1510
|
+
return data
|
|
1511
|
+
|
|
1512
|
+
def list_backups_with_http_info(self, body, **kwargs): # noqa: E501
|
|
1513
|
+
"""list_backups # noqa: E501
|
|
1514
|
+
|
|
1515
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1516
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1517
|
+
>>> thread = api.list_backups_with_http_info(body, async_req=True)
|
|
1518
|
+
>>> result = thread.get()
|
|
1519
|
+
|
|
1520
|
+
:param async_req bool
|
|
1521
|
+
:param ListBackupsRequest body: (required)
|
|
1522
|
+
:return: ListBackupsResponse
|
|
1523
|
+
If the method is called asynchronously,
|
|
1524
|
+
returns the request thread.
|
|
1525
|
+
"""
|
|
1526
|
+
|
|
1527
|
+
all_params = ['body'] # noqa: E501
|
|
1528
|
+
all_params.append('async_req')
|
|
1529
|
+
all_params.append('_return_http_data_only')
|
|
1530
|
+
all_params.append('_preload_content')
|
|
1531
|
+
all_params.append('_request_timeout')
|
|
1532
|
+
|
|
1533
|
+
params = locals()
|
|
1534
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
1535
|
+
if key not in all_params:
|
|
1536
|
+
raise TypeError(
|
|
1537
|
+
"Got an unexpected keyword argument '%s'"
|
|
1538
|
+
" to method list_backups" % key
|
|
1539
|
+
)
|
|
1540
|
+
params[key] = val
|
|
1541
|
+
del params['kwargs']
|
|
1542
|
+
# verify the required parameter 'body' is set
|
|
1543
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
1544
|
+
params['body'] is None): # noqa: E501
|
|
1545
|
+
raise ValueError("Missing the required parameter `body` when calling `list_backups`") # noqa: E501
|
|
1546
|
+
|
|
1547
|
+
collection_formats = {}
|
|
1548
|
+
|
|
1549
|
+
path_params = {}
|
|
1550
|
+
|
|
1551
|
+
query_params = []
|
|
1552
|
+
|
|
1553
|
+
header_params = {}
|
|
1554
|
+
|
|
1555
|
+
form_params = []
|
|
1556
|
+
local_var_files = {}
|
|
1557
|
+
|
|
1558
|
+
body_params = None
|
|
1559
|
+
if 'body' in params:
|
|
1560
|
+
body_params = params['body']
|
|
1561
|
+
# HTTP header `Accept`
|
|
1562
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
1563
|
+
['application/json']) # noqa: E501
|
|
1564
|
+
|
|
1565
|
+
# HTTP header `Content-Type`
|
|
1566
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
1567
|
+
['application/json']) # noqa: E501
|
|
1568
|
+
|
|
1569
|
+
# Authentication setting
|
|
1570
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
1571
|
+
|
|
1572
|
+
return self.api_client.call_api(
|
|
1573
|
+
'/ListBackups/2026-06-30/tidb/post/application_json/', 'POST',
|
|
1574
|
+
path_params,
|
|
1575
|
+
query_params,
|
|
1576
|
+
header_params,
|
|
1577
|
+
body=body_params,
|
|
1578
|
+
post_params=form_params,
|
|
1579
|
+
files=local_var_files,
|
|
1580
|
+
response_type='ListBackupsResponse', # noqa: E501
|
|
1581
|
+
auth_settings=auth_settings,
|
|
1582
|
+
async_req=params.get('async_req'),
|
|
1583
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1584
|
+
_preload_content=params.get('_preload_content', True),
|
|
1585
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1586
|
+
collection_formats=collection_formats)
|
|
1587
|
+
|
|
1588
|
+
def list_events(self, body, **kwargs): # noqa: E501
|
|
1589
|
+
"""list_events # noqa: E501
|
|
1590
|
+
|
|
1591
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1592
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1593
|
+
>>> thread = api.list_events(body, async_req=True)
|
|
1594
|
+
>>> result = thread.get()
|
|
1595
|
+
|
|
1596
|
+
:param async_req bool
|
|
1597
|
+
:param ListEventsRequest body: (required)
|
|
1598
|
+
:return: ListEventsResponse
|
|
1599
|
+
If the method is called asynchronously,
|
|
1600
|
+
returns the request thread.
|
|
1601
|
+
"""
|
|
1602
|
+
kwargs['_return_http_data_only'] = True
|
|
1603
|
+
if kwargs.get('async_req'):
|
|
1604
|
+
return self.list_events_with_http_info(body, **kwargs) # noqa: E501
|
|
1605
|
+
else:
|
|
1606
|
+
(data) = self.list_events_with_http_info(body, **kwargs) # noqa: E501
|
|
1607
|
+
return data
|
|
1608
|
+
|
|
1609
|
+
def list_events_with_http_info(self, body, **kwargs): # noqa: E501
|
|
1610
|
+
"""list_events # noqa: E501
|
|
1611
|
+
|
|
1612
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1613
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1614
|
+
>>> thread = api.list_events_with_http_info(body, async_req=True)
|
|
1615
|
+
>>> result = thread.get()
|
|
1616
|
+
|
|
1617
|
+
:param async_req bool
|
|
1618
|
+
:param ListEventsRequest body: (required)
|
|
1619
|
+
:return: ListEventsResponse
|
|
1620
|
+
If the method is called asynchronously,
|
|
1621
|
+
returns the request thread.
|
|
1622
|
+
"""
|
|
1623
|
+
|
|
1624
|
+
all_params = ['body'] # noqa: E501
|
|
1625
|
+
all_params.append('async_req')
|
|
1626
|
+
all_params.append('_return_http_data_only')
|
|
1627
|
+
all_params.append('_preload_content')
|
|
1628
|
+
all_params.append('_request_timeout')
|
|
1629
|
+
|
|
1630
|
+
params = locals()
|
|
1631
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
1632
|
+
if key not in all_params:
|
|
1633
|
+
raise TypeError(
|
|
1634
|
+
"Got an unexpected keyword argument '%s'"
|
|
1635
|
+
" to method list_events" % key
|
|
1636
|
+
)
|
|
1637
|
+
params[key] = val
|
|
1638
|
+
del params['kwargs']
|
|
1639
|
+
# verify the required parameter 'body' is set
|
|
1640
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
1641
|
+
params['body'] is None): # noqa: E501
|
|
1642
|
+
raise ValueError("Missing the required parameter `body` when calling `list_events`") # noqa: E501
|
|
1643
|
+
|
|
1644
|
+
collection_formats = {}
|
|
1645
|
+
|
|
1646
|
+
path_params = {}
|
|
1647
|
+
|
|
1648
|
+
query_params = []
|
|
1649
|
+
|
|
1650
|
+
header_params = {}
|
|
1651
|
+
|
|
1652
|
+
form_params = []
|
|
1653
|
+
local_var_files = {}
|
|
1654
|
+
|
|
1655
|
+
body_params = None
|
|
1656
|
+
if 'body' in params:
|
|
1657
|
+
body_params = params['body']
|
|
1658
|
+
# HTTP header `Accept`
|
|
1659
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
1660
|
+
['application/json']) # noqa: E501
|
|
1661
|
+
|
|
1662
|
+
# HTTP header `Content-Type`
|
|
1663
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
1664
|
+
['application/json']) # noqa: E501
|
|
1665
|
+
|
|
1666
|
+
# Authentication setting
|
|
1667
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
1668
|
+
|
|
1669
|
+
return self.api_client.call_api(
|
|
1670
|
+
'/ListEvents/2026-06-30/tidb/post/application_json/', 'POST',
|
|
1671
|
+
path_params,
|
|
1672
|
+
query_params,
|
|
1673
|
+
header_params,
|
|
1674
|
+
body=body_params,
|
|
1675
|
+
post_params=form_params,
|
|
1676
|
+
files=local_var_files,
|
|
1677
|
+
response_type='ListEventsResponse', # noqa: E501
|
|
1678
|
+
auth_settings=auth_settings,
|
|
1679
|
+
async_req=params.get('async_req'),
|
|
1680
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1681
|
+
_preload_content=params.get('_preload_content', True),
|
|
1682
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1683
|
+
collection_formats=collection_formats)
|
|
1684
|
+
|
|
1685
|
+
def list_export_tasks(self, body, **kwargs): # noqa: E501
|
|
1686
|
+
"""list_export_tasks # noqa: E501
|
|
1687
|
+
|
|
1688
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1689
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1690
|
+
>>> thread = api.list_export_tasks(body, async_req=True)
|
|
1691
|
+
>>> result = thread.get()
|
|
1692
|
+
|
|
1693
|
+
:param async_req bool
|
|
1694
|
+
:param ListExportTasksRequest body: (required)
|
|
1695
|
+
:return: ListExportTasksResponse
|
|
1696
|
+
If the method is called asynchronously,
|
|
1697
|
+
returns the request thread.
|
|
1698
|
+
"""
|
|
1699
|
+
kwargs['_return_http_data_only'] = True
|
|
1700
|
+
if kwargs.get('async_req'):
|
|
1701
|
+
return self.list_export_tasks_with_http_info(body, **kwargs) # noqa: E501
|
|
1702
|
+
else:
|
|
1703
|
+
(data) = self.list_export_tasks_with_http_info(body, **kwargs) # noqa: E501
|
|
1704
|
+
return data
|
|
1705
|
+
|
|
1706
|
+
def list_export_tasks_with_http_info(self, body, **kwargs): # noqa: E501
|
|
1707
|
+
"""list_export_tasks # noqa: E501
|
|
1708
|
+
|
|
1709
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1710
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1711
|
+
>>> thread = api.list_export_tasks_with_http_info(body, async_req=True)
|
|
1712
|
+
>>> result = thread.get()
|
|
1713
|
+
|
|
1714
|
+
:param async_req bool
|
|
1715
|
+
:param ListExportTasksRequest body: (required)
|
|
1716
|
+
:return: ListExportTasksResponse
|
|
1717
|
+
If the method is called asynchronously,
|
|
1718
|
+
returns the request thread.
|
|
1719
|
+
"""
|
|
1720
|
+
|
|
1721
|
+
all_params = ['body'] # noqa: E501
|
|
1722
|
+
all_params.append('async_req')
|
|
1723
|
+
all_params.append('_return_http_data_only')
|
|
1724
|
+
all_params.append('_preload_content')
|
|
1725
|
+
all_params.append('_request_timeout')
|
|
1726
|
+
|
|
1727
|
+
params = locals()
|
|
1728
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
1729
|
+
if key not in all_params:
|
|
1730
|
+
raise TypeError(
|
|
1731
|
+
"Got an unexpected keyword argument '%s'"
|
|
1732
|
+
" to method list_export_tasks" % key
|
|
1733
|
+
)
|
|
1734
|
+
params[key] = val
|
|
1735
|
+
del params['kwargs']
|
|
1736
|
+
# verify the required parameter 'body' is set
|
|
1737
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
1738
|
+
params['body'] is None): # noqa: E501
|
|
1739
|
+
raise ValueError("Missing the required parameter `body` when calling `list_export_tasks`") # noqa: E501
|
|
1740
|
+
|
|
1741
|
+
collection_formats = {}
|
|
1742
|
+
|
|
1743
|
+
path_params = {}
|
|
1744
|
+
|
|
1745
|
+
query_params = []
|
|
1746
|
+
|
|
1747
|
+
header_params = {}
|
|
1748
|
+
|
|
1749
|
+
form_params = []
|
|
1750
|
+
local_var_files = {}
|
|
1751
|
+
|
|
1752
|
+
body_params = None
|
|
1753
|
+
if 'body' in params:
|
|
1754
|
+
body_params = params['body']
|
|
1755
|
+
# HTTP header `Accept`
|
|
1756
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
1757
|
+
['application/json']) # noqa: E501
|
|
1758
|
+
|
|
1759
|
+
# HTTP header `Content-Type`
|
|
1760
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
1761
|
+
['application/json']) # noqa: E501
|
|
1762
|
+
|
|
1763
|
+
# Authentication setting
|
|
1764
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
1765
|
+
|
|
1766
|
+
return self.api_client.call_api(
|
|
1767
|
+
'/ListExportTasks/2026-06-30/tidb/post/application_json/', 'POST',
|
|
1768
|
+
path_params,
|
|
1769
|
+
query_params,
|
|
1770
|
+
header_params,
|
|
1771
|
+
body=body_params,
|
|
1772
|
+
post_params=form_params,
|
|
1773
|
+
files=local_var_files,
|
|
1774
|
+
response_type='ListExportTasksResponse', # noqa: E501
|
|
1775
|
+
auth_settings=auth_settings,
|
|
1776
|
+
async_req=params.get('async_req'),
|
|
1777
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1778
|
+
_preload_content=params.get('_preload_content', True),
|
|
1779
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1780
|
+
collection_formats=collection_formats)
|
|
1781
|
+
|
|
1782
|
+
def list_import_supported_data_types(self, body, **kwargs): # noqa: E501
|
|
1783
|
+
"""list_import_supported_data_types # noqa: E501
|
|
1784
|
+
|
|
1785
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1786
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1787
|
+
>>> thread = api.list_import_supported_data_types(body, async_req=True)
|
|
1788
|
+
>>> result = thread.get()
|
|
1789
|
+
|
|
1790
|
+
:param async_req bool
|
|
1791
|
+
:param ListImportSupportedDataTypesRequest body: (required)
|
|
1792
|
+
:return: ListImportSupportedDataTypesResponse
|
|
1793
|
+
If the method is called asynchronously,
|
|
1794
|
+
returns the request thread.
|
|
1795
|
+
"""
|
|
1796
|
+
kwargs['_return_http_data_only'] = True
|
|
1797
|
+
if kwargs.get('async_req'):
|
|
1798
|
+
return self.list_import_supported_data_types_with_http_info(body, **kwargs) # noqa: E501
|
|
1799
|
+
else:
|
|
1800
|
+
(data) = self.list_import_supported_data_types_with_http_info(body, **kwargs) # noqa: E501
|
|
1801
|
+
return data
|
|
1802
|
+
|
|
1803
|
+
def list_import_supported_data_types_with_http_info(self, body, **kwargs): # noqa: E501
|
|
1804
|
+
"""list_import_supported_data_types # noqa: E501
|
|
1805
|
+
|
|
1806
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1807
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1808
|
+
>>> thread = api.list_import_supported_data_types_with_http_info(body, async_req=True)
|
|
1809
|
+
>>> result = thread.get()
|
|
1810
|
+
|
|
1811
|
+
:param async_req bool
|
|
1812
|
+
:param ListImportSupportedDataTypesRequest body: (required)
|
|
1813
|
+
:return: ListImportSupportedDataTypesResponse
|
|
1814
|
+
If the method is called asynchronously,
|
|
1815
|
+
returns the request thread.
|
|
1816
|
+
"""
|
|
1817
|
+
|
|
1818
|
+
all_params = ['body'] # noqa: E501
|
|
1819
|
+
all_params.append('async_req')
|
|
1820
|
+
all_params.append('_return_http_data_only')
|
|
1821
|
+
all_params.append('_preload_content')
|
|
1822
|
+
all_params.append('_request_timeout')
|
|
1823
|
+
|
|
1824
|
+
params = locals()
|
|
1825
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
1826
|
+
if key not in all_params:
|
|
1827
|
+
raise TypeError(
|
|
1828
|
+
"Got an unexpected keyword argument '%s'"
|
|
1829
|
+
" to method list_import_supported_data_types" % key
|
|
1830
|
+
)
|
|
1831
|
+
params[key] = val
|
|
1832
|
+
del params['kwargs']
|
|
1833
|
+
# verify the required parameter 'body' is set
|
|
1834
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
1835
|
+
params['body'] is None): # noqa: E501
|
|
1836
|
+
raise ValueError("Missing the required parameter `body` when calling `list_import_supported_data_types`") # noqa: E501
|
|
1837
|
+
|
|
1838
|
+
collection_formats = {}
|
|
1839
|
+
|
|
1840
|
+
path_params = {}
|
|
1841
|
+
|
|
1842
|
+
query_params = []
|
|
1843
|
+
|
|
1844
|
+
header_params = {}
|
|
1845
|
+
|
|
1846
|
+
form_params = []
|
|
1847
|
+
local_var_files = {}
|
|
1848
|
+
|
|
1849
|
+
body_params = None
|
|
1850
|
+
if 'body' in params:
|
|
1851
|
+
body_params = params['body']
|
|
1852
|
+
# HTTP header `Accept`
|
|
1853
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
1854
|
+
['application/json']) # noqa: E501
|
|
1855
|
+
|
|
1856
|
+
# HTTP header `Content-Type`
|
|
1857
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
1858
|
+
['application/json']) # noqa: E501
|
|
1859
|
+
|
|
1860
|
+
# Authentication setting
|
|
1861
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
1862
|
+
|
|
1863
|
+
return self.api_client.call_api(
|
|
1864
|
+
'/ListImportSupportedDataTypes/2026-06-30/tidb/post/application_json/', 'POST',
|
|
1865
|
+
path_params,
|
|
1866
|
+
query_params,
|
|
1867
|
+
header_params,
|
|
1868
|
+
body=body_params,
|
|
1869
|
+
post_params=form_params,
|
|
1870
|
+
files=local_var_files,
|
|
1871
|
+
response_type='ListImportSupportedDataTypesResponse', # noqa: E501
|
|
1872
|
+
auth_settings=auth_settings,
|
|
1873
|
+
async_req=params.get('async_req'),
|
|
1874
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1875
|
+
_preload_content=params.get('_preload_content', True),
|
|
1876
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1877
|
+
collection_formats=collection_formats)
|
|
1878
|
+
|
|
1879
|
+
def list_import_target_tables(self, body, **kwargs): # noqa: E501
|
|
1880
|
+
"""list_import_target_tables # noqa: E501
|
|
1881
|
+
|
|
1882
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1883
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1884
|
+
>>> thread = api.list_import_target_tables(body, async_req=True)
|
|
1885
|
+
>>> result = thread.get()
|
|
1886
|
+
|
|
1887
|
+
:param async_req bool
|
|
1888
|
+
:param ListImportTargetTablesRequest body: (required)
|
|
1889
|
+
:return: ListImportTargetTablesResponse
|
|
1890
|
+
If the method is called asynchronously,
|
|
1891
|
+
returns the request thread.
|
|
1892
|
+
"""
|
|
1893
|
+
kwargs['_return_http_data_only'] = True
|
|
1894
|
+
if kwargs.get('async_req'):
|
|
1895
|
+
return self.list_import_target_tables_with_http_info(body, **kwargs) # noqa: E501
|
|
1896
|
+
else:
|
|
1897
|
+
(data) = self.list_import_target_tables_with_http_info(body, **kwargs) # noqa: E501
|
|
1898
|
+
return data
|
|
1899
|
+
|
|
1900
|
+
def list_import_target_tables_with_http_info(self, body, **kwargs): # noqa: E501
|
|
1901
|
+
"""list_import_target_tables # noqa: E501
|
|
1902
|
+
|
|
1903
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1904
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1905
|
+
>>> thread = api.list_import_target_tables_with_http_info(body, async_req=True)
|
|
1906
|
+
>>> result = thread.get()
|
|
1907
|
+
|
|
1908
|
+
:param async_req bool
|
|
1909
|
+
:param ListImportTargetTablesRequest body: (required)
|
|
1910
|
+
:return: ListImportTargetTablesResponse
|
|
1911
|
+
If the method is called asynchronously,
|
|
1912
|
+
returns the request thread.
|
|
1913
|
+
"""
|
|
1914
|
+
|
|
1915
|
+
all_params = ['body'] # noqa: E501
|
|
1916
|
+
all_params.append('async_req')
|
|
1917
|
+
all_params.append('_return_http_data_only')
|
|
1918
|
+
all_params.append('_preload_content')
|
|
1919
|
+
all_params.append('_request_timeout')
|
|
1920
|
+
|
|
1921
|
+
params = locals()
|
|
1922
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
1923
|
+
if key not in all_params:
|
|
1924
|
+
raise TypeError(
|
|
1925
|
+
"Got an unexpected keyword argument '%s'"
|
|
1926
|
+
" to method list_import_target_tables" % key
|
|
1927
|
+
)
|
|
1928
|
+
params[key] = val
|
|
1929
|
+
del params['kwargs']
|
|
1930
|
+
# verify the required parameter 'body' is set
|
|
1931
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
1932
|
+
params['body'] is None): # noqa: E501
|
|
1933
|
+
raise ValueError("Missing the required parameter `body` when calling `list_import_target_tables`") # noqa: E501
|
|
1934
|
+
|
|
1935
|
+
collection_formats = {}
|
|
1936
|
+
|
|
1937
|
+
path_params = {}
|
|
1938
|
+
|
|
1939
|
+
query_params = []
|
|
1940
|
+
|
|
1941
|
+
header_params = {}
|
|
1942
|
+
|
|
1943
|
+
form_params = []
|
|
1944
|
+
local_var_files = {}
|
|
1945
|
+
|
|
1946
|
+
body_params = None
|
|
1947
|
+
if 'body' in params:
|
|
1948
|
+
body_params = params['body']
|
|
1949
|
+
# HTTP header `Accept`
|
|
1950
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
1951
|
+
['application/json']) # noqa: E501
|
|
1952
|
+
|
|
1953
|
+
# HTTP header `Content-Type`
|
|
1954
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
1955
|
+
['application/json']) # noqa: E501
|
|
1956
|
+
|
|
1957
|
+
# Authentication setting
|
|
1958
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
1959
|
+
|
|
1960
|
+
return self.api_client.call_api(
|
|
1961
|
+
'/ListImportTargetTables/2026-06-30/tidb/post/application_json/', 'POST',
|
|
1962
|
+
path_params,
|
|
1963
|
+
query_params,
|
|
1964
|
+
header_params,
|
|
1965
|
+
body=body_params,
|
|
1966
|
+
post_params=form_params,
|
|
1967
|
+
files=local_var_files,
|
|
1968
|
+
response_type='ListImportTargetTablesResponse', # noqa: E501
|
|
1969
|
+
auth_settings=auth_settings,
|
|
1970
|
+
async_req=params.get('async_req'),
|
|
1971
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
1972
|
+
_preload_content=params.get('_preload_content', True),
|
|
1973
|
+
_request_timeout=params.get('_request_timeout'),
|
|
1974
|
+
collection_formats=collection_formats)
|
|
1975
|
+
|
|
1976
|
+
def list_import_tasks(self, body, **kwargs): # noqa: E501
|
|
1977
|
+
"""list_import_tasks # noqa: E501
|
|
1978
|
+
|
|
1979
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1980
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1981
|
+
>>> thread = api.list_import_tasks(body, async_req=True)
|
|
1982
|
+
>>> result = thread.get()
|
|
1983
|
+
|
|
1984
|
+
:param async_req bool
|
|
1985
|
+
:param ListImportTasksRequest body: (required)
|
|
1986
|
+
:return: ListImportTasksResponse
|
|
1987
|
+
If the method is called asynchronously,
|
|
1988
|
+
returns the request thread.
|
|
1989
|
+
"""
|
|
1990
|
+
kwargs['_return_http_data_only'] = True
|
|
1991
|
+
if kwargs.get('async_req'):
|
|
1992
|
+
return self.list_import_tasks_with_http_info(body, **kwargs) # noqa: E501
|
|
1993
|
+
else:
|
|
1994
|
+
(data) = self.list_import_tasks_with_http_info(body, **kwargs) # noqa: E501
|
|
1995
|
+
return data
|
|
1996
|
+
|
|
1997
|
+
def list_import_tasks_with_http_info(self, body, **kwargs): # noqa: E501
|
|
1998
|
+
"""list_import_tasks # noqa: E501
|
|
1999
|
+
|
|
2000
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2001
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2002
|
+
>>> thread = api.list_import_tasks_with_http_info(body, async_req=True)
|
|
2003
|
+
>>> result = thread.get()
|
|
2004
|
+
|
|
2005
|
+
:param async_req bool
|
|
2006
|
+
:param ListImportTasksRequest body: (required)
|
|
2007
|
+
:return: ListImportTasksResponse
|
|
2008
|
+
If the method is called asynchronously,
|
|
2009
|
+
returns the request thread.
|
|
2010
|
+
"""
|
|
2011
|
+
|
|
2012
|
+
all_params = ['body'] # noqa: E501
|
|
2013
|
+
all_params.append('async_req')
|
|
2014
|
+
all_params.append('_return_http_data_only')
|
|
2015
|
+
all_params.append('_preload_content')
|
|
2016
|
+
all_params.append('_request_timeout')
|
|
2017
|
+
|
|
2018
|
+
params = locals()
|
|
2019
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2020
|
+
if key not in all_params:
|
|
2021
|
+
raise TypeError(
|
|
2022
|
+
"Got an unexpected keyword argument '%s'"
|
|
2023
|
+
" to method list_import_tasks" % key
|
|
2024
|
+
)
|
|
2025
|
+
params[key] = val
|
|
2026
|
+
del params['kwargs']
|
|
2027
|
+
# verify the required parameter 'body' is set
|
|
2028
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2029
|
+
params['body'] is None): # noqa: E501
|
|
2030
|
+
raise ValueError("Missing the required parameter `body` when calling `list_import_tasks`") # noqa: E501
|
|
2031
|
+
|
|
2032
|
+
collection_formats = {}
|
|
2033
|
+
|
|
2034
|
+
path_params = {}
|
|
2035
|
+
|
|
2036
|
+
query_params = []
|
|
2037
|
+
|
|
2038
|
+
header_params = {}
|
|
2039
|
+
|
|
2040
|
+
form_params = []
|
|
2041
|
+
local_var_files = {}
|
|
2042
|
+
|
|
2043
|
+
body_params = None
|
|
2044
|
+
if 'body' in params:
|
|
2045
|
+
body_params = params['body']
|
|
2046
|
+
# HTTP header `Accept`
|
|
2047
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
2048
|
+
['application/json']) # noqa: E501
|
|
2049
|
+
|
|
2050
|
+
# HTTP header `Content-Type`
|
|
2051
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
2052
|
+
['application/json']) # noqa: E501
|
|
2053
|
+
|
|
2054
|
+
# Authentication setting
|
|
2055
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
2056
|
+
|
|
2057
|
+
return self.api_client.call_api(
|
|
2058
|
+
'/ListImportTasks/2026-06-30/tidb/post/application_json/', 'POST',
|
|
2059
|
+
path_params,
|
|
2060
|
+
query_params,
|
|
2061
|
+
header_params,
|
|
2062
|
+
body=body_params,
|
|
2063
|
+
post_params=form_params,
|
|
2064
|
+
files=local_var_files,
|
|
2065
|
+
response_type='ListImportTasksResponse', # noqa: E501
|
|
2066
|
+
auth_settings=auth_settings,
|
|
2067
|
+
async_req=params.get('async_req'),
|
|
2068
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
2069
|
+
_preload_content=params.get('_preload_content', True),
|
|
2070
|
+
_request_timeout=params.get('_request_timeout'),
|
|
2071
|
+
collection_formats=collection_formats)
|
|
2072
|
+
|
|
2073
|
+
def list_regions(self, body, **kwargs): # noqa: E501
|
|
2074
|
+
"""list_regions # noqa: E501
|
|
2075
|
+
|
|
2076
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2077
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2078
|
+
>>> thread = api.list_regions(body, async_req=True)
|
|
2079
|
+
>>> result = thread.get()
|
|
2080
|
+
|
|
2081
|
+
:param async_req bool
|
|
2082
|
+
:param ListRegionsRequest body: (required)
|
|
2083
|
+
:return: ListRegionsResponse
|
|
2084
|
+
If the method is called asynchronously,
|
|
2085
|
+
returns the request thread.
|
|
2086
|
+
"""
|
|
2087
|
+
kwargs['_return_http_data_only'] = True
|
|
2088
|
+
if kwargs.get('async_req'):
|
|
2089
|
+
return self.list_regions_with_http_info(body, **kwargs) # noqa: E501
|
|
2090
|
+
else:
|
|
2091
|
+
(data) = self.list_regions_with_http_info(body, **kwargs) # noqa: E501
|
|
2092
|
+
return data
|
|
2093
|
+
|
|
2094
|
+
def list_regions_with_http_info(self, body, **kwargs): # noqa: E501
|
|
2095
|
+
"""list_regions # noqa: E501
|
|
2096
|
+
|
|
2097
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2098
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2099
|
+
>>> thread = api.list_regions_with_http_info(body, async_req=True)
|
|
2100
|
+
>>> result = thread.get()
|
|
2101
|
+
|
|
2102
|
+
:param async_req bool
|
|
2103
|
+
:param ListRegionsRequest body: (required)
|
|
2104
|
+
:return: ListRegionsResponse
|
|
2105
|
+
If the method is called asynchronously,
|
|
2106
|
+
returns the request thread.
|
|
2107
|
+
"""
|
|
2108
|
+
|
|
2109
|
+
all_params = ['body'] # noqa: E501
|
|
2110
|
+
all_params.append('async_req')
|
|
2111
|
+
all_params.append('_return_http_data_only')
|
|
2112
|
+
all_params.append('_preload_content')
|
|
2113
|
+
all_params.append('_request_timeout')
|
|
2114
|
+
|
|
2115
|
+
params = locals()
|
|
2116
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2117
|
+
if key not in all_params:
|
|
2118
|
+
raise TypeError(
|
|
2119
|
+
"Got an unexpected keyword argument '%s'"
|
|
2120
|
+
" to method list_regions" % key
|
|
2121
|
+
)
|
|
2122
|
+
params[key] = val
|
|
2123
|
+
del params['kwargs']
|
|
2124
|
+
# verify the required parameter 'body' is set
|
|
2125
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2126
|
+
params['body'] is None): # noqa: E501
|
|
2127
|
+
raise ValueError("Missing the required parameter `body` when calling `list_regions`") # noqa: E501
|
|
2128
|
+
|
|
2129
|
+
collection_formats = {}
|
|
2130
|
+
|
|
2131
|
+
path_params = {}
|
|
2132
|
+
|
|
2133
|
+
query_params = []
|
|
2134
|
+
|
|
2135
|
+
header_params = {}
|
|
2136
|
+
|
|
2137
|
+
form_params = []
|
|
2138
|
+
local_var_files = {}
|
|
2139
|
+
|
|
2140
|
+
body_params = None
|
|
2141
|
+
if 'body' in params:
|
|
2142
|
+
body_params = params['body']
|
|
2143
|
+
# HTTP header `Accept`
|
|
2144
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
2145
|
+
['application/json']) # noqa: E501
|
|
2146
|
+
|
|
2147
|
+
# HTTP header `Content-Type`
|
|
2148
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
2149
|
+
['application/json']) # noqa: E501
|
|
2150
|
+
|
|
2151
|
+
# Authentication setting
|
|
2152
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
2153
|
+
|
|
2154
|
+
return self.api_client.call_api(
|
|
2155
|
+
'/ListRegions/2026-06-30/tidb/post/application_json/', 'POST',
|
|
2156
|
+
path_params,
|
|
2157
|
+
query_params,
|
|
2158
|
+
header_params,
|
|
2159
|
+
body=body_params,
|
|
2160
|
+
post_params=form_params,
|
|
2161
|
+
files=local_var_files,
|
|
2162
|
+
response_type='ListRegionsResponse', # noqa: E501
|
|
2163
|
+
auth_settings=auth_settings,
|
|
2164
|
+
async_req=params.get('async_req'),
|
|
2165
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
2166
|
+
_preload_content=params.get('_preload_content', True),
|
|
2167
|
+
_request_timeout=params.get('_request_timeout'),
|
|
2168
|
+
collection_formats=collection_formats)
|
|
2169
|
+
|
|
2170
|
+
def list_slow_queries(self, body, **kwargs): # noqa: E501
|
|
2171
|
+
"""list_slow_queries # noqa: E501
|
|
2172
|
+
|
|
2173
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2174
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2175
|
+
>>> thread = api.list_slow_queries(body, async_req=True)
|
|
2176
|
+
>>> result = thread.get()
|
|
2177
|
+
|
|
2178
|
+
:param async_req bool
|
|
2179
|
+
:param ListSlowQueriesRequest body: (required)
|
|
2180
|
+
:return: ListSlowQueriesResponse
|
|
2181
|
+
If the method is called asynchronously,
|
|
2182
|
+
returns the request thread.
|
|
2183
|
+
"""
|
|
2184
|
+
kwargs['_return_http_data_only'] = True
|
|
2185
|
+
if kwargs.get('async_req'):
|
|
2186
|
+
return self.list_slow_queries_with_http_info(body, **kwargs) # noqa: E501
|
|
2187
|
+
else:
|
|
2188
|
+
(data) = self.list_slow_queries_with_http_info(body, **kwargs) # noqa: E501
|
|
2189
|
+
return data
|
|
2190
|
+
|
|
2191
|
+
def list_slow_queries_with_http_info(self, body, **kwargs): # noqa: E501
|
|
2192
|
+
"""list_slow_queries # noqa: E501
|
|
2193
|
+
|
|
2194
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2195
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2196
|
+
>>> thread = api.list_slow_queries_with_http_info(body, async_req=True)
|
|
2197
|
+
>>> result = thread.get()
|
|
2198
|
+
|
|
2199
|
+
:param async_req bool
|
|
2200
|
+
:param ListSlowQueriesRequest body: (required)
|
|
2201
|
+
:return: ListSlowQueriesResponse
|
|
2202
|
+
If the method is called asynchronously,
|
|
2203
|
+
returns the request thread.
|
|
2204
|
+
"""
|
|
2205
|
+
|
|
2206
|
+
all_params = ['body'] # noqa: E501
|
|
2207
|
+
all_params.append('async_req')
|
|
2208
|
+
all_params.append('_return_http_data_only')
|
|
2209
|
+
all_params.append('_preload_content')
|
|
2210
|
+
all_params.append('_request_timeout')
|
|
2211
|
+
|
|
2212
|
+
params = locals()
|
|
2213
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2214
|
+
if key not in all_params:
|
|
2215
|
+
raise TypeError(
|
|
2216
|
+
"Got an unexpected keyword argument '%s'"
|
|
2217
|
+
" to method list_slow_queries" % key
|
|
2218
|
+
)
|
|
2219
|
+
params[key] = val
|
|
2220
|
+
del params['kwargs']
|
|
2221
|
+
# verify the required parameter 'body' is set
|
|
2222
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2223
|
+
params['body'] is None): # noqa: E501
|
|
2224
|
+
raise ValueError("Missing the required parameter `body` when calling `list_slow_queries`") # noqa: E501
|
|
2225
|
+
|
|
2226
|
+
collection_formats = {}
|
|
2227
|
+
|
|
2228
|
+
path_params = {}
|
|
2229
|
+
|
|
2230
|
+
query_params = []
|
|
2231
|
+
|
|
2232
|
+
header_params = {}
|
|
2233
|
+
|
|
2234
|
+
form_params = []
|
|
2235
|
+
local_var_files = {}
|
|
2236
|
+
|
|
2237
|
+
body_params = None
|
|
2238
|
+
if 'body' in params:
|
|
2239
|
+
body_params = params['body']
|
|
2240
|
+
# HTTP header `Accept`
|
|
2241
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
2242
|
+
['application/json']) # noqa: E501
|
|
2243
|
+
|
|
2244
|
+
# HTTP header `Content-Type`
|
|
2245
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
2246
|
+
['application/json']) # noqa: E501
|
|
2247
|
+
|
|
2248
|
+
# Authentication setting
|
|
2249
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
2250
|
+
|
|
2251
|
+
return self.api_client.call_api(
|
|
2252
|
+
'/ListSlowQueries/2026-06-30/tidb/post/application_json/', 'POST',
|
|
2253
|
+
path_params,
|
|
2254
|
+
query_params,
|
|
2255
|
+
header_params,
|
|
2256
|
+
body=body_params,
|
|
2257
|
+
post_params=form_params,
|
|
2258
|
+
files=local_var_files,
|
|
2259
|
+
response_type='ListSlowQueriesResponse', # noqa: E501
|
|
2260
|
+
auth_settings=auth_settings,
|
|
2261
|
+
async_req=params.get('async_req'),
|
|
2262
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
2263
|
+
_preload_content=params.get('_preload_content', True),
|
|
2264
|
+
_request_timeout=params.get('_request_timeout'),
|
|
2265
|
+
collection_formats=collection_formats)
|
|
2266
|
+
|
|
2267
|
+
def list_statement_plans(self, body, **kwargs): # noqa: E501
|
|
2268
|
+
"""list_statement_plans # noqa: E501
|
|
2269
|
+
|
|
2270
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2271
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2272
|
+
>>> thread = api.list_statement_plans(body, async_req=True)
|
|
2273
|
+
>>> result = thread.get()
|
|
2274
|
+
|
|
2275
|
+
:param async_req bool
|
|
2276
|
+
:param ListStatementPlansRequest body: (required)
|
|
2277
|
+
:return: ListStatementPlansResponse
|
|
2278
|
+
If the method is called asynchronously,
|
|
2279
|
+
returns the request thread.
|
|
2280
|
+
"""
|
|
2281
|
+
kwargs['_return_http_data_only'] = True
|
|
2282
|
+
if kwargs.get('async_req'):
|
|
2283
|
+
return self.list_statement_plans_with_http_info(body, **kwargs) # noqa: E501
|
|
2284
|
+
else:
|
|
2285
|
+
(data) = self.list_statement_plans_with_http_info(body, **kwargs) # noqa: E501
|
|
2286
|
+
return data
|
|
2287
|
+
|
|
2288
|
+
def list_statement_plans_with_http_info(self, body, **kwargs): # noqa: E501
|
|
2289
|
+
"""list_statement_plans # noqa: E501
|
|
2290
|
+
|
|
2291
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2292
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2293
|
+
>>> thread = api.list_statement_plans_with_http_info(body, async_req=True)
|
|
2294
|
+
>>> result = thread.get()
|
|
2295
|
+
|
|
2296
|
+
:param async_req bool
|
|
2297
|
+
:param ListStatementPlansRequest body: (required)
|
|
2298
|
+
:return: ListStatementPlansResponse
|
|
2299
|
+
If the method is called asynchronously,
|
|
2300
|
+
returns the request thread.
|
|
2301
|
+
"""
|
|
2302
|
+
|
|
2303
|
+
all_params = ['body'] # noqa: E501
|
|
2304
|
+
all_params.append('async_req')
|
|
2305
|
+
all_params.append('_return_http_data_only')
|
|
2306
|
+
all_params.append('_preload_content')
|
|
2307
|
+
all_params.append('_request_timeout')
|
|
2308
|
+
|
|
2309
|
+
params = locals()
|
|
2310
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2311
|
+
if key not in all_params:
|
|
2312
|
+
raise TypeError(
|
|
2313
|
+
"Got an unexpected keyword argument '%s'"
|
|
2314
|
+
" to method list_statement_plans" % key
|
|
2315
|
+
)
|
|
2316
|
+
params[key] = val
|
|
2317
|
+
del params['kwargs']
|
|
2318
|
+
# verify the required parameter 'body' is set
|
|
2319
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2320
|
+
params['body'] is None): # noqa: E501
|
|
2321
|
+
raise ValueError("Missing the required parameter `body` when calling `list_statement_plans`") # noqa: E501
|
|
2322
|
+
|
|
2323
|
+
collection_formats = {}
|
|
2324
|
+
|
|
2325
|
+
path_params = {}
|
|
2326
|
+
|
|
2327
|
+
query_params = []
|
|
2328
|
+
|
|
2329
|
+
header_params = {}
|
|
2330
|
+
|
|
2331
|
+
form_params = []
|
|
2332
|
+
local_var_files = {}
|
|
2333
|
+
|
|
2334
|
+
body_params = None
|
|
2335
|
+
if 'body' in params:
|
|
2336
|
+
body_params = params['body']
|
|
2337
|
+
# HTTP header `Accept`
|
|
2338
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
2339
|
+
['application/json']) # noqa: E501
|
|
2340
|
+
|
|
2341
|
+
# HTTP header `Content-Type`
|
|
2342
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
2343
|
+
['application/json']) # noqa: E501
|
|
2344
|
+
|
|
2345
|
+
# Authentication setting
|
|
2346
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
2347
|
+
|
|
2348
|
+
return self.api_client.call_api(
|
|
2349
|
+
'/ListStatementPlans/2026-06-30/tidb/post/application_json/', 'POST',
|
|
2350
|
+
path_params,
|
|
2351
|
+
query_params,
|
|
2352
|
+
header_params,
|
|
2353
|
+
body=body_params,
|
|
2354
|
+
post_params=form_params,
|
|
2355
|
+
files=local_var_files,
|
|
2356
|
+
response_type='ListStatementPlansResponse', # noqa: E501
|
|
2357
|
+
auth_settings=auth_settings,
|
|
2358
|
+
async_req=params.get('async_req'),
|
|
2359
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
2360
|
+
_preload_content=params.get('_preload_content', True),
|
|
2361
|
+
_request_timeout=params.get('_request_timeout'),
|
|
2362
|
+
collection_formats=collection_formats)
|
|
2363
|
+
|
|
2364
|
+
def list_statement_slow_queries(self, body, **kwargs): # noqa: E501
|
|
2365
|
+
"""list_statement_slow_queries # noqa: E501
|
|
2366
|
+
|
|
2367
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2368
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2369
|
+
>>> thread = api.list_statement_slow_queries(body, async_req=True)
|
|
2370
|
+
>>> result = thread.get()
|
|
2371
|
+
|
|
2372
|
+
:param async_req bool
|
|
2373
|
+
:param ListStatementSlowQueriesRequest body: (required)
|
|
2374
|
+
:return: ListStatementSlowQueriesResponse
|
|
2375
|
+
If the method is called asynchronously,
|
|
2376
|
+
returns the request thread.
|
|
2377
|
+
"""
|
|
2378
|
+
kwargs['_return_http_data_only'] = True
|
|
2379
|
+
if kwargs.get('async_req'):
|
|
2380
|
+
return self.list_statement_slow_queries_with_http_info(body, **kwargs) # noqa: E501
|
|
2381
|
+
else:
|
|
2382
|
+
(data) = self.list_statement_slow_queries_with_http_info(body, **kwargs) # noqa: E501
|
|
2383
|
+
return data
|
|
2384
|
+
|
|
2385
|
+
def list_statement_slow_queries_with_http_info(self, body, **kwargs): # noqa: E501
|
|
2386
|
+
"""list_statement_slow_queries # noqa: E501
|
|
2387
|
+
|
|
2388
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2389
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2390
|
+
>>> thread = api.list_statement_slow_queries_with_http_info(body, async_req=True)
|
|
2391
|
+
>>> result = thread.get()
|
|
2392
|
+
|
|
2393
|
+
:param async_req bool
|
|
2394
|
+
:param ListStatementSlowQueriesRequest body: (required)
|
|
2395
|
+
:return: ListStatementSlowQueriesResponse
|
|
2396
|
+
If the method is called asynchronously,
|
|
2397
|
+
returns the request thread.
|
|
2398
|
+
"""
|
|
2399
|
+
|
|
2400
|
+
all_params = ['body'] # noqa: E501
|
|
2401
|
+
all_params.append('async_req')
|
|
2402
|
+
all_params.append('_return_http_data_only')
|
|
2403
|
+
all_params.append('_preload_content')
|
|
2404
|
+
all_params.append('_request_timeout')
|
|
2405
|
+
|
|
2406
|
+
params = locals()
|
|
2407
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2408
|
+
if key not in all_params:
|
|
2409
|
+
raise TypeError(
|
|
2410
|
+
"Got an unexpected keyword argument '%s'"
|
|
2411
|
+
" to method list_statement_slow_queries" % key
|
|
2412
|
+
)
|
|
2413
|
+
params[key] = val
|
|
2414
|
+
del params['kwargs']
|
|
2415
|
+
# verify the required parameter 'body' is set
|
|
2416
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2417
|
+
params['body'] is None): # noqa: E501
|
|
2418
|
+
raise ValueError("Missing the required parameter `body` when calling `list_statement_slow_queries`") # noqa: E501
|
|
2419
|
+
|
|
2420
|
+
collection_formats = {}
|
|
2421
|
+
|
|
2422
|
+
path_params = {}
|
|
2423
|
+
|
|
2424
|
+
query_params = []
|
|
2425
|
+
|
|
2426
|
+
header_params = {}
|
|
2427
|
+
|
|
2428
|
+
form_params = []
|
|
2429
|
+
local_var_files = {}
|
|
2430
|
+
|
|
2431
|
+
body_params = None
|
|
2432
|
+
if 'body' in params:
|
|
2433
|
+
body_params = params['body']
|
|
2434
|
+
# HTTP header `Accept`
|
|
2435
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
2436
|
+
['application/json']) # noqa: E501
|
|
2437
|
+
|
|
2438
|
+
# HTTP header `Content-Type`
|
|
2439
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
2440
|
+
['application/json']) # noqa: E501
|
|
2441
|
+
|
|
2442
|
+
# Authentication setting
|
|
2443
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
2444
|
+
|
|
2445
|
+
return self.api_client.call_api(
|
|
2446
|
+
'/ListStatementSlowQueries/2026-06-30/tidb/post/application_json/', 'POST',
|
|
2447
|
+
path_params,
|
|
2448
|
+
query_params,
|
|
2449
|
+
header_params,
|
|
2450
|
+
body=body_params,
|
|
2451
|
+
post_params=form_params,
|
|
2452
|
+
files=local_var_files,
|
|
2453
|
+
response_type='ListStatementSlowQueriesResponse', # noqa: E501
|
|
2454
|
+
auth_settings=auth_settings,
|
|
2455
|
+
async_req=params.get('async_req'),
|
|
2456
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
2457
|
+
_preload_content=params.get('_preload_content', True),
|
|
2458
|
+
_request_timeout=params.get('_request_timeout'),
|
|
2459
|
+
collection_formats=collection_formats)
|
|
2460
|
+
|
|
2461
|
+
def list_statement_types(self, body, **kwargs): # noqa: E501
|
|
2462
|
+
"""list_statement_types # noqa: E501
|
|
2463
|
+
|
|
2464
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2465
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2466
|
+
>>> thread = api.list_statement_types(body, async_req=True)
|
|
2467
|
+
>>> result = thread.get()
|
|
2468
|
+
|
|
2469
|
+
:param async_req bool
|
|
2470
|
+
:param ListStatementTypesRequest body: (required)
|
|
2471
|
+
:return: ListStatementTypesResponse
|
|
2472
|
+
If the method is called asynchronously,
|
|
2473
|
+
returns the request thread.
|
|
2474
|
+
"""
|
|
2475
|
+
kwargs['_return_http_data_only'] = True
|
|
2476
|
+
if kwargs.get('async_req'):
|
|
2477
|
+
return self.list_statement_types_with_http_info(body, **kwargs) # noqa: E501
|
|
2478
|
+
else:
|
|
2479
|
+
(data) = self.list_statement_types_with_http_info(body, **kwargs) # noqa: E501
|
|
2480
|
+
return data
|
|
2481
|
+
|
|
2482
|
+
def list_statement_types_with_http_info(self, body, **kwargs): # noqa: E501
|
|
2483
|
+
"""list_statement_types # noqa: E501
|
|
2484
|
+
|
|
2485
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2486
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2487
|
+
>>> thread = api.list_statement_types_with_http_info(body, async_req=True)
|
|
2488
|
+
>>> result = thread.get()
|
|
2489
|
+
|
|
2490
|
+
:param async_req bool
|
|
2491
|
+
:param ListStatementTypesRequest body: (required)
|
|
2492
|
+
:return: ListStatementTypesResponse
|
|
2493
|
+
If the method is called asynchronously,
|
|
2494
|
+
returns the request thread.
|
|
2495
|
+
"""
|
|
2496
|
+
|
|
2497
|
+
all_params = ['body'] # noqa: E501
|
|
2498
|
+
all_params.append('async_req')
|
|
2499
|
+
all_params.append('_return_http_data_only')
|
|
2500
|
+
all_params.append('_preload_content')
|
|
2501
|
+
all_params.append('_request_timeout')
|
|
2502
|
+
|
|
2503
|
+
params = locals()
|
|
2504
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2505
|
+
if key not in all_params:
|
|
2506
|
+
raise TypeError(
|
|
2507
|
+
"Got an unexpected keyword argument '%s'"
|
|
2508
|
+
" to method list_statement_types" % key
|
|
2509
|
+
)
|
|
2510
|
+
params[key] = val
|
|
2511
|
+
del params['kwargs']
|
|
2512
|
+
# verify the required parameter 'body' is set
|
|
2513
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2514
|
+
params['body'] is None): # noqa: E501
|
|
2515
|
+
raise ValueError("Missing the required parameter `body` when calling `list_statement_types`") # noqa: E501
|
|
2516
|
+
|
|
2517
|
+
collection_formats = {}
|
|
2518
|
+
|
|
2519
|
+
path_params = {}
|
|
2520
|
+
|
|
2521
|
+
query_params = []
|
|
2522
|
+
|
|
2523
|
+
header_params = {}
|
|
2524
|
+
|
|
2525
|
+
form_params = []
|
|
2526
|
+
local_var_files = {}
|
|
2527
|
+
|
|
2528
|
+
body_params = None
|
|
2529
|
+
if 'body' in params:
|
|
2530
|
+
body_params = params['body']
|
|
2531
|
+
# HTTP header `Accept`
|
|
2532
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
2533
|
+
['application/json']) # noqa: E501
|
|
2534
|
+
|
|
2535
|
+
# HTTP header `Content-Type`
|
|
2536
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
2537
|
+
['application/json']) # noqa: E501
|
|
2538
|
+
|
|
2539
|
+
# Authentication setting
|
|
2540
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
2541
|
+
|
|
2542
|
+
return self.api_client.call_api(
|
|
2543
|
+
'/ListStatementTypes/2026-06-30/tidb/post/application_json/', 'POST',
|
|
2544
|
+
path_params,
|
|
2545
|
+
query_params,
|
|
2546
|
+
header_params,
|
|
2547
|
+
body=body_params,
|
|
2548
|
+
post_params=form_params,
|
|
2549
|
+
files=local_var_files,
|
|
2550
|
+
response_type='ListStatementTypesResponse', # noqa: E501
|
|
2551
|
+
auth_settings=auth_settings,
|
|
2552
|
+
async_req=params.get('async_req'),
|
|
2553
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
2554
|
+
_preload_content=params.get('_preload_content', True),
|
|
2555
|
+
_request_timeout=params.get('_request_timeout'),
|
|
2556
|
+
collection_formats=collection_formats)
|
|
2557
|
+
|
|
2558
|
+
def list_statements(self, body, **kwargs): # noqa: E501
|
|
2559
|
+
"""list_statements # noqa: E501
|
|
2560
|
+
|
|
2561
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2562
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2563
|
+
>>> thread = api.list_statements(body, async_req=True)
|
|
2564
|
+
>>> result = thread.get()
|
|
2565
|
+
|
|
2566
|
+
:param async_req bool
|
|
2567
|
+
:param ListStatementsRequest body: (required)
|
|
2568
|
+
:return: ListStatementsResponse
|
|
2569
|
+
If the method is called asynchronously,
|
|
2570
|
+
returns the request thread.
|
|
2571
|
+
"""
|
|
2572
|
+
kwargs['_return_http_data_only'] = True
|
|
2573
|
+
if kwargs.get('async_req'):
|
|
2574
|
+
return self.list_statements_with_http_info(body, **kwargs) # noqa: E501
|
|
2575
|
+
else:
|
|
2576
|
+
(data) = self.list_statements_with_http_info(body, **kwargs) # noqa: E501
|
|
2577
|
+
return data
|
|
2578
|
+
|
|
2579
|
+
def list_statements_with_http_info(self, body, **kwargs): # noqa: E501
|
|
2580
|
+
"""list_statements # noqa: E501
|
|
2581
|
+
|
|
2582
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2583
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2584
|
+
>>> thread = api.list_statements_with_http_info(body, async_req=True)
|
|
2585
|
+
>>> result = thread.get()
|
|
2586
|
+
|
|
2587
|
+
:param async_req bool
|
|
2588
|
+
:param ListStatementsRequest body: (required)
|
|
2589
|
+
:return: ListStatementsResponse
|
|
2590
|
+
If the method is called asynchronously,
|
|
2591
|
+
returns the request thread.
|
|
2592
|
+
"""
|
|
2593
|
+
|
|
2594
|
+
all_params = ['body'] # noqa: E501
|
|
2595
|
+
all_params.append('async_req')
|
|
2596
|
+
all_params.append('_return_http_data_only')
|
|
2597
|
+
all_params.append('_preload_content')
|
|
2598
|
+
all_params.append('_request_timeout')
|
|
2599
|
+
|
|
2600
|
+
params = locals()
|
|
2601
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2602
|
+
if key not in all_params:
|
|
2603
|
+
raise TypeError(
|
|
2604
|
+
"Got an unexpected keyword argument '%s'"
|
|
2605
|
+
" to method list_statements" % key
|
|
2606
|
+
)
|
|
2607
|
+
params[key] = val
|
|
2608
|
+
del params['kwargs']
|
|
2609
|
+
# verify the required parameter 'body' is set
|
|
2610
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2611
|
+
params['body'] is None): # noqa: E501
|
|
2612
|
+
raise ValueError("Missing the required parameter `body` when calling `list_statements`") # noqa: E501
|
|
2613
|
+
|
|
2614
|
+
collection_formats = {}
|
|
2615
|
+
|
|
2616
|
+
path_params = {}
|
|
2617
|
+
|
|
2618
|
+
query_params = []
|
|
2619
|
+
|
|
2620
|
+
header_params = {}
|
|
2621
|
+
|
|
2622
|
+
form_params = []
|
|
2623
|
+
local_var_files = {}
|
|
2624
|
+
|
|
2625
|
+
body_params = None
|
|
2626
|
+
if 'body' in params:
|
|
2627
|
+
body_params = params['body']
|
|
2628
|
+
# HTTP header `Accept`
|
|
2629
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
2630
|
+
['application/json']) # noqa: E501
|
|
2631
|
+
|
|
2632
|
+
# HTTP header `Content-Type`
|
|
2633
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
2634
|
+
['application/json']) # noqa: E501
|
|
2635
|
+
|
|
2636
|
+
# Authentication setting
|
|
2637
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
2638
|
+
|
|
2639
|
+
return self.api_client.call_api(
|
|
2640
|
+
'/ListStatements/2026-06-30/tidb/post/application_json/', 'POST',
|
|
2641
|
+
path_params,
|
|
2642
|
+
query_params,
|
|
2643
|
+
header_params,
|
|
2644
|
+
body=body_params,
|
|
2645
|
+
post_params=form_params,
|
|
2646
|
+
files=local_var_files,
|
|
2647
|
+
response_type='ListStatementsResponse', # noqa: E501
|
|
2648
|
+
auth_settings=auth_settings,
|
|
2649
|
+
async_req=params.get('async_req'),
|
|
2650
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
2651
|
+
_preload_content=params.get('_preload_content', True),
|
|
2652
|
+
_request_timeout=params.get('_request_timeout'),
|
|
2653
|
+
collection_formats=collection_formats)
|
|
2654
|
+
|
|
2655
|
+
def list_zones(self, body, **kwargs): # noqa: E501
|
|
2656
|
+
"""list_zones # noqa: E501
|
|
2657
|
+
|
|
2658
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2659
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2660
|
+
>>> thread = api.list_zones(body, async_req=True)
|
|
2661
|
+
>>> result = thread.get()
|
|
2662
|
+
|
|
2663
|
+
:param async_req bool
|
|
2664
|
+
:param ListZonesRequest body: (required)
|
|
2665
|
+
:return: ListZonesResponse
|
|
2666
|
+
If the method is called asynchronously,
|
|
2667
|
+
returns the request thread.
|
|
2668
|
+
"""
|
|
2669
|
+
kwargs['_return_http_data_only'] = True
|
|
2670
|
+
if kwargs.get('async_req'):
|
|
2671
|
+
return self.list_zones_with_http_info(body, **kwargs) # noqa: E501
|
|
2672
|
+
else:
|
|
2673
|
+
(data) = self.list_zones_with_http_info(body, **kwargs) # noqa: E501
|
|
2674
|
+
return data
|
|
2675
|
+
|
|
2676
|
+
def list_zones_with_http_info(self, body, **kwargs): # noqa: E501
|
|
2677
|
+
"""list_zones # noqa: E501
|
|
2678
|
+
|
|
2679
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2680
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2681
|
+
>>> thread = api.list_zones_with_http_info(body, async_req=True)
|
|
2682
|
+
>>> result = thread.get()
|
|
2683
|
+
|
|
2684
|
+
:param async_req bool
|
|
2685
|
+
:param ListZonesRequest body: (required)
|
|
2686
|
+
:return: ListZonesResponse
|
|
2687
|
+
If the method is called asynchronously,
|
|
2688
|
+
returns the request thread.
|
|
2689
|
+
"""
|
|
2690
|
+
|
|
2691
|
+
all_params = ['body'] # noqa: E501
|
|
2692
|
+
all_params.append('async_req')
|
|
2693
|
+
all_params.append('_return_http_data_only')
|
|
2694
|
+
all_params.append('_preload_content')
|
|
2695
|
+
all_params.append('_request_timeout')
|
|
2696
|
+
|
|
2697
|
+
params = locals()
|
|
2698
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2699
|
+
if key not in all_params:
|
|
2700
|
+
raise TypeError(
|
|
2701
|
+
"Got an unexpected keyword argument '%s'"
|
|
2702
|
+
" to method list_zones" % key
|
|
2703
|
+
)
|
|
2704
|
+
params[key] = val
|
|
2705
|
+
del params['kwargs']
|
|
2706
|
+
# verify the required parameter 'body' is set
|
|
2707
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2708
|
+
params['body'] is None): # noqa: E501
|
|
2709
|
+
raise ValueError("Missing the required parameter `body` when calling `list_zones`") # noqa: E501
|
|
2710
|
+
|
|
2711
|
+
collection_formats = {}
|
|
2712
|
+
|
|
2713
|
+
path_params = {}
|
|
2714
|
+
|
|
2715
|
+
query_params = []
|
|
2716
|
+
|
|
2717
|
+
header_params = {}
|
|
2718
|
+
|
|
2719
|
+
form_params = []
|
|
2720
|
+
local_var_files = {}
|
|
2721
|
+
|
|
2722
|
+
body_params = None
|
|
2723
|
+
if 'body' in params:
|
|
2724
|
+
body_params = params['body']
|
|
2725
|
+
# HTTP header `Accept`
|
|
2726
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
2727
|
+
['application/json']) # noqa: E501
|
|
2728
|
+
|
|
2729
|
+
# HTTP header `Content-Type`
|
|
2730
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
2731
|
+
['application/json']) # noqa: E501
|
|
2732
|
+
|
|
2733
|
+
# Authentication setting
|
|
2734
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
2735
|
+
|
|
2736
|
+
return self.api_client.call_api(
|
|
2737
|
+
'/ListZones/2026-06-30/tidb/post/application_json/', 'POST',
|
|
2738
|
+
path_params,
|
|
2739
|
+
query_params,
|
|
2740
|
+
header_params,
|
|
2741
|
+
body=body_params,
|
|
2742
|
+
post_params=form_params,
|
|
2743
|
+
files=local_var_files,
|
|
2744
|
+
response_type='ListZonesResponse', # noqa: E501
|
|
2745
|
+
auth_settings=auth_settings,
|
|
2746
|
+
async_req=params.get('async_req'),
|
|
2747
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
2748
|
+
_preload_content=params.get('_preload_content', True),
|
|
2749
|
+
_request_timeout=params.get('_request_timeout'),
|
|
2750
|
+
collection_formats=collection_formats)
|
|
2751
|
+
|
|
2752
|
+
def precheck_import_task(self, body, **kwargs): # noqa: E501
|
|
2753
|
+
"""precheck_import_task # noqa: E501
|
|
2754
|
+
|
|
2755
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2756
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2757
|
+
>>> thread = api.precheck_import_task(body, async_req=True)
|
|
2758
|
+
>>> result = thread.get()
|
|
2759
|
+
|
|
2760
|
+
:param async_req bool
|
|
2761
|
+
:param PrecheckImportTaskRequest body: (required)
|
|
2762
|
+
:return: PrecheckImportTaskResponse
|
|
2763
|
+
If the method is called asynchronously,
|
|
2764
|
+
returns the request thread.
|
|
2765
|
+
"""
|
|
2766
|
+
kwargs['_return_http_data_only'] = True
|
|
2767
|
+
if kwargs.get('async_req'):
|
|
2768
|
+
return self.precheck_import_task_with_http_info(body, **kwargs) # noqa: E501
|
|
2769
|
+
else:
|
|
2770
|
+
(data) = self.precheck_import_task_with_http_info(body, **kwargs) # noqa: E501
|
|
2771
|
+
return data
|
|
2772
|
+
|
|
2773
|
+
def precheck_import_task_with_http_info(self, body, **kwargs): # noqa: E501
|
|
2774
|
+
"""precheck_import_task # noqa: E501
|
|
2775
|
+
|
|
2776
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2777
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2778
|
+
>>> thread = api.precheck_import_task_with_http_info(body, async_req=True)
|
|
2779
|
+
>>> result = thread.get()
|
|
2780
|
+
|
|
2781
|
+
:param async_req bool
|
|
2782
|
+
:param PrecheckImportTaskRequest body: (required)
|
|
2783
|
+
:return: PrecheckImportTaskResponse
|
|
2784
|
+
If the method is called asynchronously,
|
|
2785
|
+
returns the request thread.
|
|
2786
|
+
"""
|
|
2787
|
+
|
|
2788
|
+
all_params = ['body'] # noqa: E501
|
|
2789
|
+
all_params.append('async_req')
|
|
2790
|
+
all_params.append('_return_http_data_only')
|
|
2791
|
+
all_params.append('_preload_content')
|
|
2792
|
+
all_params.append('_request_timeout')
|
|
2793
|
+
|
|
2794
|
+
params = locals()
|
|
2795
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2796
|
+
if key not in all_params:
|
|
2797
|
+
raise TypeError(
|
|
2798
|
+
"Got an unexpected keyword argument '%s'"
|
|
2799
|
+
" to method precheck_import_task" % key
|
|
2800
|
+
)
|
|
2801
|
+
params[key] = val
|
|
2802
|
+
del params['kwargs']
|
|
2803
|
+
# verify the required parameter 'body' is set
|
|
2804
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2805
|
+
params['body'] is None): # noqa: E501
|
|
2806
|
+
raise ValueError("Missing the required parameter `body` when calling `precheck_import_task`") # noqa: E501
|
|
2807
|
+
|
|
2808
|
+
collection_formats = {}
|
|
2809
|
+
|
|
2810
|
+
path_params = {}
|
|
2811
|
+
|
|
2812
|
+
query_params = []
|
|
2813
|
+
|
|
2814
|
+
header_params = {}
|
|
2815
|
+
|
|
2816
|
+
form_params = []
|
|
2817
|
+
local_var_files = {}
|
|
2818
|
+
|
|
2819
|
+
body_params = None
|
|
2820
|
+
if 'body' in params:
|
|
2821
|
+
body_params = params['body']
|
|
2822
|
+
# HTTP header `Accept`
|
|
2823
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
2824
|
+
['application/json']) # noqa: E501
|
|
2825
|
+
|
|
2826
|
+
# HTTP header `Content-Type`
|
|
2827
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
2828
|
+
['application/json']) # noqa: E501
|
|
2829
|
+
|
|
2830
|
+
# Authentication setting
|
|
2831
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
2832
|
+
|
|
2833
|
+
return self.api_client.call_api(
|
|
2834
|
+
'/PrecheckImportTask/2026-06-30/tidb/post/application_json/', 'POST',
|
|
2835
|
+
path_params,
|
|
2836
|
+
query_params,
|
|
2837
|
+
header_params,
|
|
2838
|
+
body=body_params,
|
|
2839
|
+
post_params=form_params,
|
|
2840
|
+
files=local_var_files,
|
|
2841
|
+
response_type='PrecheckImportTaskResponse', # noqa: E501
|
|
2842
|
+
auth_settings=auth_settings,
|
|
2843
|
+
async_req=params.get('async_req'),
|
|
2844
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
2845
|
+
_preload_content=params.get('_preload_content', True),
|
|
2846
|
+
_request_timeout=params.get('_request_timeout'),
|
|
2847
|
+
collection_formats=collection_formats)
|
|
2848
|
+
|
|
2849
|
+
def preview_local_import(self, body, **kwargs): # noqa: E501
|
|
2850
|
+
"""preview_local_import # noqa: E501
|
|
2851
|
+
|
|
2852
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2853
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2854
|
+
>>> thread = api.preview_local_import(body, async_req=True)
|
|
2855
|
+
>>> result = thread.get()
|
|
2856
|
+
|
|
2857
|
+
:param async_req bool
|
|
2858
|
+
:param PreviewLocalImportRequest body: (required)
|
|
2859
|
+
:return: PreviewLocalImportResponse
|
|
2860
|
+
If the method is called asynchronously,
|
|
2861
|
+
returns the request thread.
|
|
2862
|
+
"""
|
|
2863
|
+
kwargs['_return_http_data_only'] = True
|
|
2864
|
+
if kwargs.get('async_req'):
|
|
2865
|
+
return self.preview_local_import_with_http_info(body, **kwargs) # noqa: E501
|
|
2866
|
+
else:
|
|
2867
|
+
(data) = self.preview_local_import_with_http_info(body, **kwargs) # noqa: E501
|
|
2868
|
+
return data
|
|
2869
|
+
|
|
2870
|
+
def preview_local_import_with_http_info(self, body, **kwargs): # noqa: E501
|
|
2871
|
+
"""preview_local_import # noqa: E501
|
|
2872
|
+
|
|
2873
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2874
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2875
|
+
>>> thread = api.preview_local_import_with_http_info(body, async_req=True)
|
|
2876
|
+
>>> result = thread.get()
|
|
2877
|
+
|
|
2878
|
+
:param async_req bool
|
|
2879
|
+
:param PreviewLocalImportRequest body: (required)
|
|
2880
|
+
:return: PreviewLocalImportResponse
|
|
2881
|
+
If the method is called asynchronously,
|
|
2882
|
+
returns the request thread.
|
|
2883
|
+
"""
|
|
2884
|
+
|
|
2885
|
+
all_params = ['body'] # noqa: E501
|
|
2886
|
+
all_params.append('async_req')
|
|
2887
|
+
all_params.append('_return_http_data_only')
|
|
2888
|
+
all_params.append('_preload_content')
|
|
2889
|
+
all_params.append('_request_timeout')
|
|
2890
|
+
|
|
2891
|
+
params = locals()
|
|
2892
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2893
|
+
if key not in all_params:
|
|
2894
|
+
raise TypeError(
|
|
2895
|
+
"Got an unexpected keyword argument '%s'"
|
|
2896
|
+
" to method preview_local_import" % key
|
|
2897
|
+
)
|
|
2898
|
+
params[key] = val
|
|
2899
|
+
del params['kwargs']
|
|
2900
|
+
# verify the required parameter 'body' is set
|
|
2901
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2902
|
+
params['body'] is None): # noqa: E501
|
|
2903
|
+
raise ValueError("Missing the required parameter `body` when calling `preview_local_import`") # noqa: E501
|
|
2904
|
+
|
|
2905
|
+
collection_formats = {}
|
|
2906
|
+
|
|
2907
|
+
path_params = {}
|
|
2908
|
+
|
|
2909
|
+
query_params = []
|
|
2910
|
+
|
|
2911
|
+
header_params = {}
|
|
2912
|
+
|
|
2913
|
+
form_params = []
|
|
2914
|
+
local_var_files = {}
|
|
2915
|
+
|
|
2916
|
+
body_params = None
|
|
2917
|
+
if 'body' in params:
|
|
2918
|
+
body_params = params['body']
|
|
2919
|
+
# HTTP header `Accept`
|
|
2920
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
2921
|
+
['application/json']) # noqa: E501
|
|
2922
|
+
|
|
2923
|
+
# HTTP header `Content-Type`
|
|
2924
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
2925
|
+
['application/json']) # noqa: E501
|
|
2926
|
+
|
|
2927
|
+
# Authentication setting
|
|
2928
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
2929
|
+
|
|
2930
|
+
return self.api_client.call_api(
|
|
2931
|
+
'/PreviewLocalImport/2026-06-30/tidb/post/application_json/', 'POST',
|
|
2932
|
+
path_params,
|
|
2933
|
+
query_params,
|
|
2934
|
+
header_params,
|
|
2935
|
+
body=body_params,
|
|
2936
|
+
post_params=form_params,
|
|
2937
|
+
files=local_var_files,
|
|
2938
|
+
response_type='PreviewLocalImportResponse', # noqa: E501
|
|
2939
|
+
auth_settings=auth_settings,
|
|
2940
|
+
async_req=params.get('async_req'),
|
|
2941
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
2942
|
+
_preload_content=params.get('_preload_content', True),
|
|
2943
|
+
_request_timeout=params.get('_request_timeout'),
|
|
2944
|
+
collection_formats=collection_formats)
|
|
2945
|
+
|
|
2946
|
+
def restore_cluster(self, body, **kwargs): # noqa: E501
|
|
2947
|
+
"""restore_cluster # noqa: E501
|
|
2948
|
+
|
|
2949
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2950
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2951
|
+
>>> thread = api.restore_cluster(body, async_req=True)
|
|
2952
|
+
>>> result = thread.get()
|
|
2953
|
+
|
|
2954
|
+
:param async_req bool
|
|
2955
|
+
:param RestoreClusterRequest body: (required)
|
|
2956
|
+
:return: RestoreClusterResponse
|
|
2957
|
+
If the method is called asynchronously,
|
|
2958
|
+
returns the request thread.
|
|
2959
|
+
"""
|
|
2960
|
+
kwargs['_return_http_data_only'] = True
|
|
2961
|
+
if kwargs.get('async_req'):
|
|
2962
|
+
return self.restore_cluster_with_http_info(body, **kwargs) # noqa: E501
|
|
2963
|
+
else:
|
|
2964
|
+
(data) = self.restore_cluster_with_http_info(body, **kwargs) # noqa: E501
|
|
2965
|
+
return data
|
|
2966
|
+
|
|
2967
|
+
def restore_cluster_with_http_info(self, body, **kwargs): # noqa: E501
|
|
2968
|
+
"""restore_cluster # noqa: E501
|
|
2969
|
+
|
|
2970
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2971
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2972
|
+
>>> thread = api.restore_cluster_with_http_info(body, async_req=True)
|
|
2973
|
+
>>> result = thread.get()
|
|
2974
|
+
|
|
2975
|
+
:param async_req bool
|
|
2976
|
+
:param RestoreClusterRequest body: (required)
|
|
2977
|
+
:return: RestoreClusterResponse
|
|
2978
|
+
If the method is called asynchronously,
|
|
2979
|
+
returns the request thread.
|
|
2980
|
+
"""
|
|
2981
|
+
|
|
2982
|
+
all_params = ['body'] # noqa: E501
|
|
2983
|
+
all_params.append('async_req')
|
|
2984
|
+
all_params.append('_return_http_data_only')
|
|
2985
|
+
all_params.append('_preload_content')
|
|
2986
|
+
all_params.append('_request_timeout')
|
|
2987
|
+
|
|
2988
|
+
params = locals()
|
|
2989
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
2990
|
+
if key not in all_params:
|
|
2991
|
+
raise TypeError(
|
|
2992
|
+
"Got an unexpected keyword argument '%s'"
|
|
2993
|
+
" to method restore_cluster" % key
|
|
2994
|
+
)
|
|
2995
|
+
params[key] = val
|
|
2996
|
+
del params['kwargs']
|
|
2997
|
+
# verify the required parameter 'body' is set
|
|
2998
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
2999
|
+
params['body'] is None): # noqa: E501
|
|
3000
|
+
raise ValueError("Missing the required parameter `body` when calling `restore_cluster`") # noqa: E501
|
|
3001
|
+
|
|
3002
|
+
collection_formats = {}
|
|
3003
|
+
|
|
3004
|
+
path_params = {}
|
|
3005
|
+
|
|
3006
|
+
query_params = []
|
|
3007
|
+
|
|
3008
|
+
header_params = {}
|
|
3009
|
+
|
|
3010
|
+
form_params = []
|
|
3011
|
+
local_var_files = {}
|
|
3012
|
+
|
|
3013
|
+
body_params = None
|
|
3014
|
+
if 'body' in params:
|
|
3015
|
+
body_params = params['body']
|
|
3016
|
+
# HTTP header `Accept`
|
|
3017
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
3018
|
+
['application/json']) # noqa: E501
|
|
3019
|
+
|
|
3020
|
+
# HTTP header `Content-Type`
|
|
3021
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
3022
|
+
['application/json']) # noqa: E501
|
|
3023
|
+
|
|
3024
|
+
# Authentication setting
|
|
3025
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
3026
|
+
|
|
3027
|
+
return self.api_client.call_api(
|
|
3028
|
+
'/RestoreCluster/2026-06-30/tidb/post/application_json/', 'POST',
|
|
3029
|
+
path_params,
|
|
3030
|
+
query_params,
|
|
3031
|
+
header_params,
|
|
3032
|
+
body=body_params,
|
|
3033
|
+
post_params=form_params,
|
|
3034
|
+
files=local_var_files,
|
|
3035
|
+
response_type='RestoreClusterResponse', # noqa: E501
|
|
3036
|
+
auth_settings=auth_settings,
|
|
3037
|
+
async_req=params.get('async_req'),
|
|
3038
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
3039
|
+
_preload_content=params.get('_preload_content', True),
|
|
3040
|
+
_request_timeout=params.get('_request_timeout'),
|
|
3041
|
+
collection_formats=collection_formats)
|
|
3042
|
+
|
|
3043
|
+
def validate_import_task(self, body, **kwargs): # noqa: E501
|
|
3044
|
+
"""validate_import_task # noqa: E501
|
|
3045
|
+
|
|
3046
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
3047
|
+
asynchronous HTTP request, please pass async_req=True
|
|
3048
|
+
>>> thread = api.validate_import_task(body, async_req=True)
|
|
3049
|
+
>>> result = thread.get()
|
|
3050
|
+
|
|
3051
|
+
:param async_req bool
|
|
3052
|
+
:param ValidateImportTaskRequest body: (required)
|
|
3053
|
+
:return: ValidateImportTaskResponse
|
|
3054
|
+
If the method is called asynchronously,
|
|
3055
|
+
returns the request thread.
|
|
3056
|
+
"""
|
|
3057
|
+
kwargs['_return_http_data_only'] = True
|
|
3058
|
+
if kwargs.get('async_req'):
|
|
3059
|
+
return self.validate_import_task_with_http_info(body, **kwargs) # noqa: E501
|
|
3060
|
+
else:
|
|
3061
|
+
(data) = self.validate_import_task_with_http_info(body, **kwargs) # noqa: E501
|
|
3062
|
+
return data
|
|
3063
|
+
|
|
3064
|
+
def validate_import_task_with_http_info(self, body, **kwargs): # noqa: E501
|
|
3065
|
+
"""validate_import_task # noqa: E501
|
|
3066
|
+
|
|
3067
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
3068
|
+
asynchronous HTTP request, please pass async_req=True
|
|
3069
|
+
>>> thread = api.validate_import_task_with_http_info(body, async_req=True)
|
|
3070
|
+
>>> result = thread.get()
|
|
3071
|
+
|
|
3072
|
+
:param async_req bool
|
|
3073
|
+
:param ValidateImportTaskRequest body: (required)
|
|
3074
|
+
:return: ValidateImportTaskResponse
|
|
3075
|
+
If the method is called asynchronously,
|
|
3076
|
+
returns the request thread.
|
|
3077
|
+
"""
|
|
3078
|
+
|
|
3079
|
+
all_params = ['body'] # noqa: E501
|
|
3080
|
+
all_params.append('async_req')
|
|
3081
|
+
all_params.append('_return_http_data_only')
|
|
3082
|
+
all_params.append('_preload_content')
|
|
3083
|
+
all_params.append('_request_timeout')
|
|
3084
|
+
|
|
3085
|
+
params = locals()
|
|
3086
|
+
for key, val in six.iteritems(params['kwargs']):
|
|
3087
|
+
if key not in all_params:
|
|
3088
|
+
raise TypeError(
|
|
3089
|
+
"Got an unexpected keyword argument '%s'"
|
|
3090
|
+
" to method validate_import_task" % key
|
|
3091
|
+
)
|
|
3092
|
+
params[key] = val
|
|
3093
|
+
del params['kwargs']
|
|
3094
|
+
# verify the required parameter 'body' is set
|
|
3095
|
+
if self.api_client.client_side_validation and ('body' not in params or
|
|
3096
|
+
params['body'] is None): # noqa: E501
|
|
3097
|
+
raise ValueError("Missing the required parameter `body` when calling `validate_import_task`") # noqa: E501
|
|
3098
|
+
|
|
3099
|
+
collection_formats = {}
|
|
3100
|
+
|
|
3101
|
+
path_params = {}
|
|
3102
|
+
|
|
3103
|
+
query_params = []
|
|
3104
|
+
|
|
3105
|
+
header_params = {}
|
|
3106
|
+
|
|
3107
|
+
form_params = []
|
|
3108
|
+
local_var_files = {}
|
|
3109
|
+
|
|
3110
|
+
body_params = None
|
|
3111
|
+
if 'body' in params:
|
|
3112
|
+
body_params = params['body']
|
|
3113
|
+
# HTTP header `Accept`
|
|
3114
|
+
header_params['Accept'] = self.api_client.select_header_accept(
|
|
3115
|
+
['application/json']) # noqa: E501
|
|
3116
|
+
|
|
3117
|
+
# HTTP header `Content-Type`
|
|
3118
|
+
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
|
|
3119
|
+
['application/json']) # noqa: E501
|
|
3120
|
+
|
|
3121
|
+
# Authentication setting
|
|
3122
|
+
auth_settings = ['volcengineSign'] # noqa: E501
|
|
3123
|
+
|
|
3124
|
+
return self.api_client.call_api(
|
|
3125
|
+
'/ValidateImportTask/2026-06-30/tidb/post/application_json/', 'POST',
|
|
3126
|
+
path_params,
|
|
3127
|
+
query_params,
|
|
3128
|
+
header_params,
|
|
3129
|
+
body=body_params,
|
|
3130
|
+
post_params=form_params,
|
|
3131
|
+
files=local_var_files,
|
|
3132
|
+
response_type='ValidateImportTaskResponse', # noqa: E501
|
|
3133
|
+
auth_settings=auth_settings,
|
|
3134
|
+
async_req=params.get('async_req'),
|
|
3135
|
+
_return_http_data_only=params.get('_return_http_data_only'),
|
|
3136
|
+
_preload_content=params.get('_preload_content', True),
|
|
3137
|
+
_request_timeout=params.get('_request_timeout'),
|
|
3138
|
+
collection_formats=collection_formats)
|