alibabacloud-fc20230330 4.5.0__py3-none-any.whl → 4.6.1__py3-none-any.whl

alibabacloud_fc20230330/__init__.py

@@ -1 +1 @@
-__version__ = '4.5.0'
+__version__ = '4.6.1'

alibabacloud_fc20230330/client.py

@@ -555,6 +555,116 @@ class Client(OpenApiClient):
         headers = {}
         return await self.create_layer_version_with_options_async(layer_name, request, headers, runtime)
 
+    def create_session_with_options(
+        self,
+        function_name: str,
+        request: fc20230330_models.CreateSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.CreateSessionResponse:
+        """
+        @summary 创建会话资源
+        
+        @param request: CreateSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: CreateSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(request.body)
+        )
+        params = open_api_models.Params(
+            action='CreateSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.CreateSessionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def create_session_with_options_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.CreateSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.CreateSessionResponse:
+        """
+        @summary 创建会话资源
+        
+        @param request: CreateSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: CreateSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(request.body)
+        )
+        params = open_api_models.Params(
+            action='CreateSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions',
+            method='POST',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.CreateSessionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def create_session(
+        self,
+        function_name: str,
+        request: fc20230330_models.CreateSessionRequest,
+    ) -> fc20230330_models.CreateSessionResponse:
+        """
+        @summary 创建会话资源
+        
+        @param request: CreateSessionRequest
+        @return: CreateSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.create_session_with_options(function_name, request, headers, runtime)
+
+    async def create_session_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.CreateSessionRequest,
+    ) -> fc20230330_models.CreateSessionResponse:
+        """
+        @summary 创建会话资源
+        
+        @param request: CreateSessionRequest
+        @return: CreateSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.create_session_with_options_async(function_name, request, headers, runtime)
+
     def create_trigger_with_options(
         self,
         function_name: str,
@@ -1635,6 +1745,118 @@ class Client(OpenApiClient):
         headers = {}
         return await self.delete_scaling_config_with_options_async(function_name, request, headers, runtime)
 
+    def delete_session_with_options(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.DeleteSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.DeleteSessionResponse:
+        """
+        @summary 删除会话资源
+        
+        @param request: DeleteSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: DeleteSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='DeleteSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='DELETE',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='none'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.DeleteSessionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def delete_session_with_options_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.DeleteSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.DeleteSessionResponse:
+        """
+        @summary 删除会话资源
+        
+        @param request: DeleteSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: DeleteSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='DeleteSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='DELETE',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='none'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.DeleteSessionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def delete_session(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.DeleteSessionRequest,
+    ) -> fc20230330_models.DeleteSessionResponse:
+        """
+        @summary 删除会话资源
+        
+        @param request: DeleteSessionRequest
+        @return: DeleteSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.delete_session_with_options(function_name, session_id, request, headers, runtime)
+
+    async def delete_session_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.DeleteSessionRequest,
+    ) -> fc20230330_models.DeleteSessionResponse:
+        """
+        @summary 删除会话资源
+        
+        @param request: DeleteSessionRequest
+        @return: DeleteSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.delete_session_with_options_async(function_name, session_id, request, headers, runtime)
+
     def delete_trigger_with_options(
         self,
         function_name: str,
@@ -3247,6 +3469,118 @@ class Client(OpenApiClient):
         headers = {}
         return await self.get_scaling_config_with_options_async(function_name, request, headers, runtime)
 
+    def get_session_with_options(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.GetSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.GetSessionResponse:
+        """
+        @summary 获取函数会话信息。
+        
+        @param request: GetSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='GetSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.GetSessionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def get_session_with_options_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.GetSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.GetSessionResponse:
+        """
+        @summary 获取函数会话信息。
+        
+        @param request: GetSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: GetSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='GetSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.GetSessionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def get_session(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.GetSessionRequest,
+    ) -> fc20230330_models.GetSessionResponse:
+        """
+        @summary 获取函数会话信息。
+        
+        @param request: GetSessionRequest
+        @return: GetSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.get_session_with_options(function_name, session_id, request, headers, runtime)
+
+    async def get_session_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.GetSessionRequest,
+    ) -> fc20230330_models.GetSessionResponse:
+        """
+        @summary 获取函数会话信息。
+        
+        @param request: GetSessionRequest
+        @return: GetSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.get_session_with_options_async(function_name, session_id, request, headers, runtime)
+
     def get_trigger_with_options(
         self,
         function_name: str,
@@ -4955,6 +5289,130 @@ class Client(OpenApiClient):
         headers = {}
         return await self.list_scaling_configs_with_options_async(request, headers, runtime)
 
+    def list_sessions_with_options(
+        self,
+        function_name: str,
+        request: fc20230330_models.ListSessionsRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.ListSessionsResponse:
+        """
+        @summary 列出函数会话信息
+        
+        @param request: ListSessionsRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListSessionsResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.limit):
+            query['limit'] = request.limit
+        if not UtilClient.is_unset(request.next_token):
+            query['nextToken'] = request.next_token
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        if not UtilClient.is_unset(request.session_id):
+            query['sessionId'] = request.session_id
+        if not UtilClient.is_unset(request.session_status):
+            query['sessionStatus'] = request.session_status
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListSessions',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.ListSessionsResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def list_sessions_with_options_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.ListSessionsRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.ListSessionsResponse:
+        """
+        @summary 列出函数会话信息
+        
+        @param request: ListSessionsRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: ListSessionsResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.limit):
+            query['limit'] = request.limit
+        if not UtilClient.is_unset(request.next_token):
+            query['nextToken'] = request.next_token
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        if not UtilClient.is_unset(request.session_id):
+            query['sessionId'] = request.session_id
+        if not UtilClient.is_unset(request.session_status):
+            query['sessionStatus'] = request.session_status
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query)
+        )
+        params = open_api_models.Params(
+            action='ListSessions',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions',
+            method='GET',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.ListSessionsResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def list_sessions(
+        self,
+        function_name: str,
+        request: fc20230330_models.ListSessionsRequest,
+    ) -> fc20230330_models.ListSessionsResponse:
+        """
+        @summary 列出函数会话信息
+        
+        @param request: ListSessionsRequest
+        @return: ListSessionsResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.list_sessions_with_options(function_name, request, headers, runtime)
+
+    async def list_sessions_async(
+        self,
+        function_name: str,
+        request: fc20230330_models.ListSessionsRequest,
+    ) -> fc20230330_models.ListSessionsResponse:
+        """
+        @summary 列出函数会话信息
+        
+        @param request: ListSessionsRequest
+        @return: ListSessionsResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.list_sessions_with_options_async(function_name, request, headers, runtime)
+
     def list_tag_resources_with_options(
         self,
         tmp_req: fc20230330_models.ListTagResourcesRequest,
@@ -6595,6 +7053,120 @@ class Client(OpenApiClient):
         headers = {}
         return await self.update_function_with_options_async(function_name, request, headers, runtime)
 
+    def update_session_with_options(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.UpdateSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.UpdateSessionResponse:
+        """
+        @summary 更新会话配置
+        
+        @param request: UpdateSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: UpdateSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(request.body)
+        )
+        params = open_api_models.Params(
+            action='UpdateSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='PUT',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.UpdateSessionResponse(),
+            self.call_api(params, req, runtime)
+        )
+
+    async def update_session_with_options_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.UpdateSessionRequest,
+        headers: Dict[str, str],
+        runtime: util_models.RuntimeOptions,
+    ) -> fc20230330_models.UpdateSessionResponse:
+        """
+        @summary 更新会话配置
+        
+        @param request: UpdateSessionRequest
+        @param headers: map
+        @param runtime: runtime options for this request RuntimeOptions
+        @return: UpdateSessionResponse
+        """
+        UtilClient.validate_model(request)
+        query = {}
+        if not UtilClient.is_unset(request.qualifier):
+            query['qualifier'] = request.qualifier
+        req = open_api_models.OpenApiRequest(
+            headers=headers,
+            query=OpenApiUtilClient.query(query),
+            body=OpenApiUtilClient.parse_to_map(request.body)
+        )
+        params = open_api_models.Params(
+            action='UpdateSession',
+            version='2023-03-30',
+            protocol='HTTPS',
+            pathname=f'/2023-03-30/functions/{OpenApiUtilClient.get_encode_param(function_name)}/sessions/{OpenApiUtilClient.get_encode_param(session_id)}',
+            method='PUT',
+            auth_type='AK',
+            style='ROA',
+            req_body_type='json',
+            body_type='json'
+        )
+        return TeaCore.from_map(
+            fc20230330_models.UpdateSessionResponse(),
+            await self.call_api_async(params, req, runtime)
+        )
+
+    def update_session(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.UpdateSessionRequest,
+    ) -> fc20230330_models.UpdateSessionResponse:
+        """
+        @summary 更新会话配置
+        
+        @param request: UpdateSessionRequest
+        @return: UpdateSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return self.update_session_with_options(function_name, session_id, request, headers, runtime)
+
+    async def update_session_async(
+        self,
+        function_name: str,
+        session_id: str,
+        request: fc20230330_models.UpdateSessionRequest,
+    ) -> fc20230330_models.UpdateSessionResponse:
+        """
+        @summary 更新会话配置
+        
+        @param request: UpdateSessionRequest
+        @return: UpdateSessionResponse
+        """
+        runtime = util_models.RuntimeOptions()
+        headers = {}
+        return await self.update_session_with_options_async(function_name, session_id, request, headers, runtime)
+
     def update_trigger_with_options(
         self,
         function_name: str,

alibabacloud_fc20230330/models.py

@@ -2068,6 +2068,7 @@ class CreateFunctionInput(TeaModel):
         function_name: str = None,
         gpu_config: GPUConfig = None,
         handler: str = None,
+        idle_timeout: int = None,
         instance_concurrency: int = None,
         instance_isolation_mode: str = None,
         instance_lifecycle_config: InstanceLifecycleConfig = None,
@@ -2102,6 +2103,7 @@ class CreateFunctionInput(TeaModel):
         self.gpu_config = gpu_config
         # This parameter is required.
         self.handler = handler
+        self.idle_timeout = idle_timeout
         self.instance_concurrency = instance_concurrency
         self.instance_isolation_mode = instance_isolation_mode
         self.instance_lifecycle_config = instance_lifecycle_config
@@ -2182,6 +2184,8 @@ class CreateFunctionInput(TeaModel):
             result['gpuConfig'] = self.gpu_config.to_map()
         if self.handler is not None:
             result['handler'] = self.handler
+        if self.idle_timeout is not None:
+            result['idleTimeout'] = self.idle_timeout
         if self.instance_concurrency is not None:
             result['instanceConcurrency'] = self.instance_concurrency
         if self.instance_isolation_mode is not None:
@@ -2255,6 +2259,8 @@ class CreateFunctionInput(TeaModel):
             self.gpu_config = temp_model.from_map(m['gpuConfig'])
         if m.get('handler') is not None:
             self.handler = m.get('handler')
+        if m.get('idleTimeout') is not None:
+            self.idle_timeout = m.get('idleTimeout')
         if m.get('instanceConcurrency') is not None:
             self.instance_concurrency = m.get('instanceConcurrency')
         if m.get('instanceIsolationMode') is not None:
@@ -2350,6 +2356,39 @@ class CreateLayerVersionInput(TeaModel):
         return self
 
 
+class CreateSessionInput(TeaModel):
+    def __init__(
+        self,
+        session_idle_timeout_in_seconds: int = None,
+        session_ttlin_seconds: int = None,
+    ):
+        self.session_idle_timeout_in_seconds = session_idle_timeout_in_seconds
+        self.session_ttlin_seconds = session_ttlin_seconds
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.session_idle_timeout_in_seconds is not None:
+            result['sessionIdleTimeoutInSeconds'] = self.session_idle_timeout_in_seconds
+        if self.session_ttlin_seconds is not None:
+            result['sessionTTLInSeconds'] = self.session_ttlin_seconds
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('sessionIdleTimeoutInSeconds') is not None:
+            self.session_idle_timeout_in_seconds = m.get('sessionIdleTimeoutInSeconds')
+        if m.get('sessionTTLInSeconds') is not None:
+            self.session_ttlin_seconds = m.get('sessionTTLInSeconds')
+        return self
+
+
 class CreateTriggerInput(TeaModel):
     def __init__(
         self,
@@ -3792,6 +3831,7 @@ class Function(TeaModel):
         function_name: str = None,
         gpu_config: GPUConfig = None,
         handler: str = None,
+        idle_timeout: int = None,
         instance_concurrency: int = None,
         instance_isolation_mode: str = None,
         instance_lifecycle_config: InstanceLifecycleConfig = None,
@@ -3836,6 +3876,7 @@ class Function(TeaModel):
         self.function_name = function_name
         self.gpu_config = gpu_config
         self.handler = handler
+        self.idle_timeout = idle_timeout
         self.instance_concurrency = instance_concurrency
         self.instance_isolation_mode = instance_isolation_mode
         self.instance_lifecycle_config = instance_lifecycle_config
@@ -3935,6 +3976,8 @@ class Function(TeaModel):
             result['gpuConfig'] = self.gpu_config.to_map()
         if self.handler is not None:
             result['handler'] = self.handler
+        if self.idle_timeout is not None:
+            result['idleTimeout'] = self.idle_timeout
         if self.instance_concurrency is not None:
             result['instanceConcurrency'] = self.instance_concurrency
         if self.instance_isolation_mode is not None:
@@ -4033,6 +4076,8 @@ class Function(TeaModel):
             self.gpu_config = temp_model.from_map(m['gpuConfig'])
         if m.get('handler') is not None:
             self.handler = m.get('handler')
+        if m.get('idleTimeout') is not None:
+            self.idle_timeout = m.get('idleTimeout')
         if m.get('instanceConcurrency') is not None:
             self.instance_concurrency = m.get('instanceConcurrency')
         if m.get('instanceIsolationMode') is not None:
@@ -5720,6 +5765,128 @@ class ListScalingConfigsOutput(TeaModel):
         return self
 
 
+class Session(TeaModel):
+    def __init__(
+        self,
+        container_id: str = None,
+        created_time: str = None,
+        function_name: str = None,
+        last_modified_time: str = None,
+        qualifier: str = None,
+        session_affinity_type: str = None,
+        session_id: str = None,
+        session_idle_timeout_in_seconds: int = None,
+        session_status: str = None,
+        session_ttlin_seconds: int = None,
+    ):
+        self.container_id = container_id
+        self.created_time = created_time
+        self.function_name = function_name
+        self.last_modified_time = last_modified_time
+        self.qualifier = qualifier
+        self.session_affinity_type = session_affinity_type
+        self.session_id = session_id
+        self.session_idle_timeout_in_seconds = session_idle_timeout_in_seconds
+        self.session_status = session_status
+        self.session_ttlin_seconds = session_ttlin_seconds
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.container_id is not None:
+            result['containerId'] = self.container_id
+        if self.created_time is not None:
+            result['createdTime'] = self.created_time
+        if self.function_name is not None:
+            result['functionName'] = self.function_name
+        if self.last_modified_time is not None:
+            result['lastModifiedTime'] = self.last_modified_time
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        if self.session_affinity_type is not None:
+            result['sessionAffinityType'] = self.session_affinity_type
+        if self.session_id is not None:
+            result['sessionId'] = self.session_id
+        if self.session_idle_timeout_in_seconds is not None:
+            result['sessionIdleTimeoutInSeconds'] = self.session_idle_timeout_in_seconds
+        if self.session_status is not None:
+            result['sessionStatus'] = self.session_status
+        if self.session_ttlin_seconds is not None:
+            result['sessionTTLInSeconds'] = self.session_ttlin_seconds
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('containerId') is not None:
+            self.container_id = m.get('containerId')
+        if m.get('createdTime') is not None:
+            self.created_time = m.get('createdTime')
+        if m.get('functionName') is not None:
+            self.function_name = m.get('functionName')
+        if m.get('lastModifiedTime') is not None:
+            self.last_modified_time = m.get('lastModifiedTime')
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        if m.get('sessionAffinityType') is not None:
+            self.session_affinity_type = m.get('sessionAffinityType')
+        if m.get('sessionId') is not None:
+            self.session_id = m.get('sessionId')
+        if m.get('sessionIdleTimeoutInSeconds') is not None:
+            self.session_idle_timeout_in_seconds = m.get('sessionIdleTimeoutInSeconds')
+        if m.get('sessionStatus') is not None:
+            self.session_status = m.get('sessionStatus')
+        if m.get('sessionTTLInSeconds') is not None:
+            self.session_ttlin_seconds = m.get('sessionTTLInSeconds')
+        return self
+
+
+class ListSessionsOutput(TeaModel):
+    def __init__(
+        self,
+        next_token: str = None,
+        sessions: List[Session] = None,
+    ):
+        self.next_token = next_token
+        self.sessions = sessions
+
+    def validate(self):
+        if self.sessions:
+            for k in self.sessions:
+                if k:
+                    k.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
+        result['sessions'] = []
+        if self.sessions is not None:
+            for k in self.sessions:
+                result['sessions'].append(k.to_map() if k else None)
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
+        self.sessions = []
+        if m.get('sessions') is not None:
+            for k in m.get('sessions'):
+                temp_model = Session()
+                self.sessions.append(temp_model.from_map(k))
+        return self
+
+
 class TagResource(TeaModel):
     def __init__(
         self,
@@ -7092,6 +7259,7 @@ class UpdateFunctionInput(TeaModel):
         environment_variables: Dict[str, str] = None,
         gpu_config: GPUConfig = None,
         handler: str = None,
+        idle_timeout: int = None,
         instance_concurrency: int = None,
         instance_isolation_mode: str = None,
         instance_lifecycle_config: InstanceLifecycleConfig = None,
@@ -7121,6 +7289,7 @@ class UpdateFunctionInput(TeaModel):
         self.environment_variables = environment_variables
         self.gpu_config = gpu_config
         self.handler = handler
+        self.idle_timeout = idle_timeout
         self.instance_concurrency = instance_concurrency
         self.instance_isolation_mode = instance_isolation_mode
         self.instance_lifecycle_config = instance_lifecycle_config
@@ -7192,6 +7361,8 @@ class UpdateFunctionInput(TeaModel):
             result['gpuConfig'] = self.gpu_config.to_map()
         if self.handler is not None:
             result['handler'] = self.handler
+        if self.idle_timeout is not None:
+            result['idleTimeout'] = self.idle_timeout
         if self.instance_concurrency is not None:
             result['instanceConcurrency'] = self.instance_concurrency
         if self.instance_isolation_mode is not None:
@@ -7257,6 +7428,8 @@ class UpdateFunctionInput(TeaModel):
             self.gpu_config = temp_model.from_map(m['gpuConfig'])
         if m.get('handler') is not None:
             self.handler = m.get('handler')
+        if m.get('idleTimeout') is not None:
+            self.idle_timeout = m.get('idleTimeout')
         if m.get('instanceConcurrency') is not None:
             self.instance_concurrency = m.get('instanceConcurrency')
         if m.get('instanceIsolationMode') is not None:
@@ -7331,6 +7504,39 @@ class UpdateResidentResourcePoolInput(TeaModel):
         return self
 
 
+class UpdateSessionInput(TeaModel):
+    def __init__(
+        self,
+        session_idle_timeout_in_seconds: int = None,
+        session_ttlin_seconds: int = None,
+    ):
+        self.session_idle_timeout_in_seconds = session_idle_timeout_in_seconds
+        self.session_ttlin_seconds = session_ttlin_seconds
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.session_idle_timeout_in_seconds is not None:
+            result['sessionIdleTimeoutInSeconds'] = self.session_idle_timeout_in_seconds
+        if self.session_ttlin_seconds is not None:
+            result['sessionTTLInSeconds'] = self.session_ttlin_seconds
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('sessionIdleTimeoutInSeconds') is not None:
+            self.session_idle_timeout_in_seconds = m.get('sessionIdleTimeoutInSeconds')
+        if m.get('sessionTTLInSeconds') is not None:
+            self.session_ttlin_seconds = m.get('sessionTTLInSeconds')
+        return self
+
+
 class UpdateTriggerInput(TeaModel):
     def __init__(
         self,
@@ -7738,6 +7944,82 @@ class CreateLayerVersionResponse(TeaModel):
         return self
 
 
+class CreateSessionRequest(TeaModel):
+    def __init__(
+        self,
+        body: CreateSessionInput = None,
+        qualifier: str = None,
+    ):
+        self.body = body
+        self.qualifier = qualifier
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('body') is not None:
+            temp_model = CreateSessionInput()
+            self.body = temp_model.from_map(m['body'])
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        return self
+
+
+class CreateSessionResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: Session = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = Session()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class CreateTriggerRequest(TeaModel):
     def __init__(
         self,
@@ -8256,6 +8538,66 @@ class DeleteScalingConfigResponse(TeaModel):
         return self
 
 
+class DeleteSessionRequest(TeaModel):
+    def __init__(
+        self,
+        qualifier: str = None,
+    ):
+        self.qualifier = qualifier
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        return self
+
+
+class DeleteSessionResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        return self
+
+
 class DeleteTriggerResponse(TeaModel):
     def __init__(
         self,
@@ -9180,6 +9522,74 @@ class GetScalingConfigResponse(TeaModel):
         return self
 
 
+class GetSessionRequest(TeaModel):
+    def __init__(
+        self,
+        qualifier: str = None,
+    ):
+        self.qualifier = qualifier
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        return self
+
+
+class GetSessionResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: Session = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = Session()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class GetTriggerResponse(TeaModel):
     def __init__(
         self,
@@ -10660,6 +11070,98 @@ class ListScalingConfigsResponse(TeaModel):
         return self
 
 
+class ListSessionsRequest(TeaModel):
+    def __init__(
+        self,
+        limit: int = None,
+        next_token: str = None,
+        qualifier: str = None,
+        session_id: str = None,
+        session_status: str = None,
+    ):
+        self.limit = limit
+        self.next_token = next_token
+        self.qualifier = qualifier
+        self.session_id = session_id
+        self.session_status = session_status
+
+    def validate(self):
+        pass
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.limit is not None:
+            result['limit'] = self.limit
+        if self.next_token is not None:
+            result['nextToken'] = self.next_token
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        if self.session_id is not None:
+            result['sessionId'] = self.session_id
+        if self.session_status is not None:
+            result['sessionStatus'] = self.session_status
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('limit') is not None:
+            self.limit = m.get('limit')
+        if m.get('nextToken') is not None:
+            self.next_token = m.get('nextToken')
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        if m.get('sessionId') is not None:
+            self.session_id = m.get('sessionId')
+        if m.get('sessionStatus') is not None:
+            self.session_status = m.get('sessionStatus')
+        return self
+
+
+class ListSessionsResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: ListSessionsOutput = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = ListSessionsOutput()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class ListTagResourcesRequestTag(TeaModel):
     def __init__(
         self,
@@ -11926,6 +12428,82 @@ class UpdateFunctionResponse(TeaModel):
         return self
 
 
+class UpdateSessionRequest(TeaModel):
+    def __init__(
+        self,
+        body: UpdateSessionInput = None,
+        qualifier: str = None,
+    ):
+        self.body = body
+        self.qualifier = qualifier
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        if self.qualifier is not None:
+            result['qualifier'] = self.qualifier
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('body') is not None:
+            temp_model = UpdateSessionInput()
+            self.body = temp_model.from_map(m['body'])
+        if m.get('qualifier') is not None:
+            self.qualifier = m.get('qualifier')
+        return self
+
+
+class UpdateSessionResponse(TeaModel):
+    def __init__(
+        self,
+        headers: Dict[str, str] = None,
+        status_code: int = None,
+        body: Session = None,
+    ):
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def validate(self):
+        if self.body:
+            self.body.validate()
+
+    def to_map(self):
+        _map = super().to_map()
+        if _map is not None:
+            return _map
+
+        result = dict()
+        if self.headers is not None:
+            result['headers'] = self.headers
+        if self.status_code is not None:
+            result['statusCode'] = self.status_code
+        if self.body is not None:
+            result['body'] = self.body.to_map()
+        return result
+
+    def from_map(self, m: dict = None):
+        m = m or dict()
+        if m.get('headers') is not None:
+            self.headers = m.get('headers')
+        if m.get('statusCode') is not None:
+            self.status_code = m.get('statusCode')
+        if m.get('body') is not None:
+            temp_model = Session()
+            self.body = temp_model.from_map(m['body'])
+        return self
+
+
 class UpdateTriggerRequest(TeaModel):
     def __init__(
         self,

{alibabacloud_fc20230330-4.5.0.dist-info → alibabacloud_fc20230330-4.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: alibabacloud-fc20230330
-Version: 4.5.0
+Version: 4.6.1
 Summary: Alibaba Cloud Function Compute (20230330) SDK Library for Python
 Home-page: https://github.com/aliyun/alibabacloud-python-sdk
 Author: Alibaba Cloud SDK

alibabacloud_fc20230330-4.6.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+alibabacloud_fc20230330/__init__.py,sha256=cvOAYcVCOqEGT6xtvMbRqTAGJKE1tRHbaFlYIOqBPcA,21
+alibabacloud_fc20230330/client.py,sha256=EWffIKYHmoI_bpbGpndUEYmy59oc5Ifm5zJJDM-s9zA,269897
+alibabacloud_fc20230330/models.py,sha256=DppE73Jl4_hitoi67woG29RHWotU59cFd7Mc1xB-uCc,403094
+alibabacloud_fc20230330-4.6.1.dist-info/LICENSE,sha256=0CFItL6bHvxqS44T6vlLoW2R4Zaic304OO3WxN0oXF0,600
+alibabacloud_fc20230330-4.6.1.dist-info/METADATA,sha256=KOE-DainGoOKbTxoYFWUQDsPzG8HXq3G1_BTkWxkoZc,2319
+alibabacloud_fc20230330-4.6.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+alibabacloud_fc20230330-4.6.1.dist-info/top_level.txt,sha256=baV3-L5IvxdXABZELkVnoxSffqdCcj44u4zGA8yQ-Ek,24
+alibabacloud_fc20230330-4.6.1.dist-info/RECORD,,

alibabacloud_fc20230330-4.5.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-alibabacloud_fc20230330/__init__.py,sha256=a4qsqPKUrk6Ur9lXXKPt7KEI5zaqiA8s2bLsPUcPw9s,21
-alibabacloud_fc20230330/client.py,sha256=YdzPPx-QAm1CotY_qqJkeoSzwlcCzDY9ddMbHoohJ-Y,249395
-alibabacloud_fc20230330/models.py,sha256=J_pzUMRrF8DAoNQazaGL67Ir0bwRpniWvp8ZwgVbV_s,385278
-alibabacloud_fc20230330-4.5.0.dist-info/LICENSE,sha256=0CFItL6bHvxqS44T6vlLoW2R4Zaic304OO3WxN0oXF0,600
-alibabacloud_fc20230330-4.5.0.dist-info/METADATA,sha256=Wy1oIoWD-WvChXecFGUSp3OpSP1ISd7lZ8Ie2u6aesc,2319
-alibabacloud_fc20230330-4.5.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-alibabacloud_fc20230330-4.5.0.dist-info/top_level.txt,sha256=baV3-L5IvxdXABZELkVnoxSffqdCcj44u4zGA8yQ-Ek,24
-alibabacloud_fc20230330-4.5.0.dist-info/RECORD,,