class Client(client.AbstractClient)

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

from tencent.cloud.auth import credentials
from tencent.cloud.serverless import functions

# Please replace with your access credentials

access_credentials = credentials.Credentials(
    secret_id = 'AKIDF3sMOAU1pOgkmrKHchX6TZQ1Mo1C5qa7',
    secret_key = 'b4JL8fwxkIgsKMXGi39yYt0ECxZw4wZf'
)

function_client: functions.Client = functions.Client(
    access_credentials = access_credentials,
    access_proxies = None
)

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

@function_client.bind_routine(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'arithmetic'
)
def addend(
    value1: int,
    value2: int
) -> int:
    raise NotImplementedError

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

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 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_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 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 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 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 run_schedule(self)

function_client.get_event_loop().run_forever()

function_client.run_schedule()

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 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 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 invoke(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_event: dict = None,
    function_version: str = None,
    function_async: bool = False
) -> dict

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

def get_function_info(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_version: str = None
) -> 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
)

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

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 get_function_result_by_request_id(self,
    region_id: str,
    namespace_name: str,
    function_name: str,
    function_request_id: str,
    function_version: str = None
) -> dict

function_client.get_function_result_by_request_id(
    region_id = 'ap-shanghai',
    namespace_name = 'default',
    function_name = 'addend',
    function_request_id = 'effae55e-480e-11ea-b078-5254007aa7a1',
    function_version = '1'
)

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 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
)

def create_namespace(self,
    region_id: str,
    namespace_name: str,
    namespace_description: str = None
)

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

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

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

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

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

function_client.create_namespace(
    region_id = 'ap-shanghai',
    namespace_name = 'test',
    namespace_description = 'New namespace'
)

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'])

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

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'
)

function_client.delete_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 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 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 list_namespaces(self,
    region_id: str
)

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

def delete_namespace(self,
    region_id: str,
    namespace_name: str
)

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

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

def create_layer(self,
    region_id: str,
    layer_name: str,
    layer_description: str,
    layer_content: LayerContent,
    layer_runtimes: list,
    layer_license: str = None
) -> int

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

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

function_client.delete_namespace(
    region_id = 'ap-shanghai',
    namespace_name = 'test',
)

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'
)

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

layer_version: int = functions_client.create_layer(
    region_id = 'ap-shanghai',
    layer_name = 'default',
    layer_description = 'default layer',
    layer_content = functions.LayerContent().use_local_zip_archive(
        local_file_path = './layer-data.zip'
    ),
    layer_runtimes = [
        functions.FunctionRuntime.Python,
        functions.FunctionRuntime.Java
    ],
    layer_license = 'default license'
).result

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 delete_layer(self,
    region_id: str,
    layer_name: str,
    layer_version: int = None
)

function_client.delete_layer(
    region_id = 'ap-shanghai',
    layer_name = 'default',
    layer_version = 1
)

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

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