def easy_invoke(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_event: dict = None,
    function_version: str = None,
    function_async: bool = False
) -> object

return_value: int = function_client.easy_invoke(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_event = {
        'value1': 10,
        'value2': 20
    },
    function_version = '1',
    function_async = False
)

def invoke(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_event: dict = None,
    function_version: str = None,
    function_async: bool = False
) -> dict

return_result: str = function_client.invoke(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_event = {
        'value1': 10,
        'value2': 20
    },
    function_version = '1',
    function_async = False
)

def update_function_configure(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_description: str = None,
    function_configure: dict = None
)

function_client.update_function_configure(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_description = 'New function description',
    function_configure = {
        'memory_size': 256
    }
)

def list_function_versions(self,
    region_id: str,
    namespace_name: str,
    function_name: str
) -> object

function_version_set = function_client.list_function_versions(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend'
)

for info in function_version_set :
    print(info['name'])

def get_function_info(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_version: str = None
) -> dict

function_info: dict = function_client.get_function_info(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_version = '1'
)

def schedule_invoke(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_event: dict = None,
    function_version: str = None,
    function_async: bool = False,
    invoke_timestamp: int = None,
    invoked_callback: object = None
) -> FunctionSchedule

import time

def schedule_callback(
    schedule_task: functions.FunctionSchedule
):
    if not schedule_task.is_successful:
        raise schedule_task.exception
    
    print(schedule_task.return_value)
    print(schedule_task.result)

schedule_task = function_client.schedule_invoke(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_event = {
        'value1': 10,
        'value2': 20
    },
    function_version = '1',
    function_async = False,
    invoke_timestamp = int(time.time()) + 5,
    invoked_callback = schedule_callback
)

# schedule_task.cancel()    # Cancel schedule

def list_namespaces(self,
    region_id: str
)

for namespace_info in function_client.list_namespaces(
    region_id = 'ap-shanghai'
):
    print(namespace_info['name'])

def get_function_code_download_url(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_version: str = None
) -> dict

download_url: str = function_client.get_function_code_download_url(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_version = '1'
)

def select_function(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_version: str = None,
    function_async: bool = False
) -> function

addend = function_client.select_function(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_version = '1',
    function_async = False
)

return_value: int = addend(
    value1 = 10,
    value2 = 20
)

def bind_function(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_version: str = None,
    function_async: bool = False,
    include_attributes: list = None
) -> object

@function_client.bind_function(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_version = '1',
    function_async = False,
    include_attributes = None
)
def addend(
    value1: int,
    value2: int
) -> int:
    raise NotImplementedError

return_value: int = addend(
    value1 = 10,
    value2 = 20
)

def submit_monitor_indicator(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    indicator_name: str,
    indicator_value: int,
    function_version: str = None
)

function_client.submit_monitor_indicator(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'hello',
    indicator_name = 'number_of_invokes',
    indicator_value = 1
)

def download_function_code(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_version: str = None,
    download_file_name: str = None
) -> dict

download_url: str = function_client.download_function_code(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_version = '1',
    download_file_name = './source.zip'
)

def get_function_results(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    requirement_context: dict = None,
    function_version: str = None
) -> object

function_results = function_client.get_function_results(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    requirement_context = {
        'type': functions.FunctionResultType.Succeed
    },
    function_version = '1'
)

# Don't worry, this method won't retrieve and get
# all the running results at this time.

for result in function_results:
    print(result['request_id'])

def create_trigger(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_trigger: FunctionTrigger,
    function_version: str = None
)

function_client.create_trigger(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_trigger = functions.FunctionTrigger().use_timer(
        timer_name = 'default',
        timer_cron = '* * * * *'
    ),
    function_version = '1'
)

def create_function(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_description: str,
    function_code: FunctionCode,
    function_runtime: str = 'Python3',
    function_type: str = None,
    function_configure: dict = None
)

function_client.create_function(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_description = 'Addition function'，
    function_code = functions.FunctionCode().use_object_storage_bucket(
        region_id = 'ap-shanghai-1',
        bucket_id = 'scf-code',
        object_name = 'source.zip'
    ),
    function_runtime = functions.FunctionRuntime.Python,
    function_type = functions.FunctionType.Event,
    function_configure = {
        'handler': 'index.main',
        'memory_size': 128,
        'time_out': 3
    }
)

def list_layer_versions(self,
    region_id: str,
    layer_name: str,
    requirement_context: dict = None
)

for layer_info in function_client.list_layer_versions(
    region_id = 'ap-shanghai',
    layer_name = 'default'
):
    print(layer_info['version'])

def select_routine(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    routine_name: str,
    function_version: str = None,
    function_async: bool = False
)

addend = function_client.select_routine(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'arithmetic',
    routine_name = 'addend'
)

return_value: int = addend(
    value1 = 10,
    value2 = 20
)

def routine_invoke(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    routine_name: str,
    routine_parameter: dict = None,
    function_version: str = None,
    function_async: bool = False
) -> object

return_value: int = function_client.routine_invoke(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'arithmetic',
    routine_name = 'addend',
    routine_parameter = {
        'value1': 10,
        'value2': 20
    }
)

def get_request_id(self) -> str

def update_namespace(self,
    region_id: str,
    namespace_name: str,
    namespace_description: str
)

function_client.update_namespace(
    region_id = 'ap-shanghai',
    namespace_name = 'test',
    namespace_description = 'Update namespace'
)

def get_layer_info(self,
    region_id: str,
    layer_name: str,
    layer_version: int
) -> dict

layer_info: dict = function_client.get_layer_info(
    region_id = 'ap-shanghai',
    layer_name = 'default',
    layer_version = 1
)

def get_trigger_kind(self) -> str

functions.FunctionTrigger().get_trigger_kind()

def delete_function(self,
    region_id: str,
    namespace_name: str,
    function_name: str
)

function_client.delete_function(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend'
)

def copy_function(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    target_region_id: str,
    target_namespace_name: str,
    target_function_name: str,
    allow_override: bool = False,
    copy_configure: bool = True
)

function_client.copy_function(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    target_region_id = 'ap-guangzhou',
    target_namespace_name = 'default',
    target_function_name = 'addend',
    allow_override = True,
    copy_configure = True
)

def publish_function_version(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    version_description: str = None
)

function_client.publish_function_version(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    version_description = 'New addition calculation function version'
)

def update_function_code(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_code: FunctionCode,
    function_handler: str
)

function_client.update_function_code(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_code = functions.FunctionCode().use_object_storage_bucket(
        region_id = 'ap-shanghai-1',
        bucket_id = 'scf-code',
        object_name = 'source.zip'
    ),
    function_handler = 'index.main'
)

def list_functions(self,
    region_id: str,
    namespace_name: str,
    requirement_context: dict = None
) -> object

function_set = function_client.list_functions(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    requirement_context = {
        'search': {
            'function_name': 'add'
        }
    }
)

for info in function_set:
    print(info['name'])

def use_message_queue_topic(self,
    topic_name: str,
    topic_instance_id: str = None,
    topic_requirement_context = None
)

functions.FunctionTrigger.use_message_queue_topic(
    topic_name = 'test-queue-topic'
)

class Client(client.AbstractClient)

def __init__(self,
    access_credentials: credentials.Credentials = None,
    access_proxies: proxies.Proxies = None
)