From aa74fe01ee1c4b7323f5bd844f65679ae18d81fa Mon Sep 17 00:00:00 2001 From: farmer Date: Tue, 16 Dec 2025 09:47:15 +0800 Subject: [PATCH 1/2] fix list_namespaced_pod method doc string typo Signed-off-by: farmer --- kubernetes/client/api/core_v1_api.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kubernetes/client/api/core_v1_api.py b/kubernetes/client/api/core_v1_api.py index 4ea0ed311b..68f2c60534 100644 --- a/kubernetes/client/api/core_v1_api.py +++ b/kubernetes/client/api/core_v1_api.py @@ -15940,7 +15940,7 @@ def list_namespaced_pod(self, namespace, **kwargs): # noqa: E501 >>> thread = api.list_namespaced_pod(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. From 03f513737545d25e66d9211c61173c201dc05655 Mon Sep 17 00:00:00 2001 From: farmer Date: Tue, 16 Dec 2025 09:54:26 +0800 Subject: [PATCH 2/2] fix list_namespaced_pod method doc string typo Signed-off-by: farmer --- kubernetes/client/api/core_v1_api.py | 822 +++++++++++++-------------- 1 file changed, 411 insertions(+), 411 deletions(-) diff --git a/kubernetes/client/api/core_v1_api.py b/kubernetes/client/api/core_v1_api.py index 68f2c60534..3bcc1db863 100644 --- a/kubernetes/client/api/core_v1_api.py +++ b/kubernetes/client/api/core_v1_api.py @@ -45,7 +45,7 @@ def connect_delete_namespaced_pod_proxy(self, name, namespace, **kwargs): # noq >>> thread = api.connect_delete_namespaced_pod_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -72,7 +72,7 @@ def connect_delete_namespaced_pod_proxy_with_http_info(self, name, namespace, ** >>> thread = api.connect_delete_namespaced_pod_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -173,7 +173,7 @@ def connect_delete_namespaced_pod_proxy_with_path(self, name, namespace, path, * >>> thread = api.connect_delete_namespaced_pod_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -201,7 +201,7 @@ def connect_delete_namespaced_pod_proxy_with_path_with_http_info(self, name, nam >>> thread = api.connect_delete_namespaced_pod_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -310,7 +310,7 @@ def connect_delete_namespaced_service_proxy(self, name, namespace, **kwargs): # >>> thread = api.connect_delete_namespaced_service_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -337,7 +337,7 @@ def connect_delete_namespaced_service_proxy_with_http_info(self, name, namespace >>> thread = api.connect_delete_namespaced_service_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -438,7 +438,7 @@ def connect_delete_namespaced_service_proxy_with_path(self, name, namespace, pat >>> thread = api.connect_delete_namespaced_service_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -466,7 +466,7 @@ def connect_delete_namespaced_service_proxy_with_path_with_http_info(self, name, >>> thread = api.connect_delete_namespaced_service_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -575,7 +575,7 @@ def connect_delete_node_proxy(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_delete_node_proxy(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -601,7 +601,7 @@ def connect_delete_node_proxy_with_http_info(self, name, **kwargs): # noqa: E50 >>> thread = api.connect_delete_node_proxy_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _return_http_data_only: response data without head status code @@ -694,7 +694,7 @@ def connect_delete_node_proxy_with_path(self, name, path, **kwargs): # noqa: E5 >>> thread = api.connect_delete_node_proxy_with_path(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -721,7 +721,7 @@ def connect_delete_node_proxy_with_path_with_http_info(self, name, path, **kwarg >>> thread = api.connect_delete_node_proxy_with_path_with_http_info(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -822,7 +822,7 @@ def connect_get_namespaced_pod_attach(self, name, namespace, **kwargs): # noqa: >>> thread = api.connect_get_namespaced_pod_attach(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodAttachOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str container: The container in which to execute the command. Defaults to only container if there is only one container in the pod. @@ -853,7 +853,7 @@ def connect_get_namespaced_pod_attach_with_http_info(self, name, namespace, **kw >>> thread = api.connect_get_namespaced_pod_attach_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodAttachOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str container: The container in which to execute the command. Defaults to only container if there is only one container in the pod. @@ -970,7 +970,7 @@ def connect_get_namespaced_pod_exec(self, name, namespace, **kwargs): # noqa: E >>> thread = api.connect_get_namespaced_pod_exec(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodExecOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str command: Command is the remote command to execute. argv array. Not executed within a shell. @@ -1002,7 +1002,7 @@ def connect_get_namespaced_pod_exec_with_http_info(self, name, namespace, **kwar >>> thread = api.connect_get_namespaced_pod_exec_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodExecOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str command: Command is the remote command to execute. argv array. Not executed within a shell. @@ -1123,7 +1123,7 @@ def connect_get_namespaced_pod_portforward(self, name, namespace, **kwargs): # >>> thread = api.connect_get_namespaced_pod_portforward(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodPortForwardOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param int ports: List of ports to forward Required when using WebSockets @@ -1150,7 +1150,7 @@ def connect_get_namespaced_pod_portforward_with_http_info(self, name, namespace, >>> thread = api.connect_get_namespaced_pod_portforward_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodPortForwardOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param int ports: List of ports to forward Required when using WebSockets @@ -1251,7 +1251,7 @@ def connect_get_namespaced_pod_proxy(self, name, namespace, **kwargs): # noqa: >>> thread = api.connect_get_namespaced_pod_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -1278,7 +1278,7 @@ def connect_get_namespaced_pod_proxy_with_http_info(self, name, namespace, **kwa >>> thread = api.connect_get_namespaced_pod_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -1379,7 +1379,7 @@ def connect_get_namespaced_pod_proxy_with_path(self, name, namespace, path, **kw >>> thread = api.connect_get_namespaced_pod_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -1407,7 +1407,7 @@ def connect_get_namespaced_pod_proxy_with_path_with_http_info(self, name, namesp >>> thread = api.connect_get_namespaced_pod_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -1516,7 +1516,7 @@ def connect_get_namespaced_service_proxy(self, name, namespace, **kwargs): # no >>> thread = api.connect_get_namespaced_service_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -1543,7 +1543,7 @@ def connect_get_namespaced_service_proxy_with_http_info(self, name, namespace, * >>> thread = api.connect_get_namespaced_service_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -1644,7 +1644,7 @@ def connect_get_namespaced_service_proxy_with_path(self, name, namespace, path, >>> thread = api.connect_get_namespaced_service_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -1672,7 +1672,7 @@ def connect_get_namespaced_service_proxy_with_path_with_http_info(self, name, na >>> thread = api.connect_get_namespaced_service_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -1781,7 +1781,7 @@ def connect_get_node_proxy(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_get_node_proxy(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -1807,7 +1807,7 @@ def connect_get_node_proxy_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_get_node_proxy_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _return_http_data_only: response data without head status code @@ -1900,7 +1900,7 @@ def connect_get_node_proxy_with_path(self, name, path, **kwargs): # noqa: E501 >>> thread = api.connect_get_node_proxy_with_path(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -1927,7 +1927,7 @@ def connect_get_node_proxy_with_path_with_http_info(self, name, path, **kwargs): >>> thread = api.connect_get_node_proxy_with_path_with_http_info(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -2028,7 +2028,7 @@ def connect_head_namespaced_pod_proxy(self, name, namespace, **kwargs): # noqa: >>> thread = api.connect_head_namespaced_pod_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -2055,7 +2055,7 @@ def connect_head_namespaced_pod_proxy_with_http_info(self, name, namespace, **kw >>> thread = api.connect_head_namespaced_pod_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -2156,7 +2156,7 @@ def connect_head_namespaced_pod_proxy_with_path(self, name, namespace, path, **k >>> thread = api.connect_head_namespaced_pod_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -2184,7 +2184,7 @@ def connect_head_namespaced_pod_proxy_with_path_with_http_info(self, name, names >>> thread = api.connect_head_namespaced_pod_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -2293,7 +2293,7 @@ def connect_head_namespaced_service_proxy(self, name, namespace, **kwargs): # n >>> thread = api.connect_head_namespaced_service_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -2320,7 +2320,7 @@ def connect_head_namespaced_service_proxy_with_http_info(self, name, namespace, >>> thread = api.connect_head_namespaced_service_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -2421,7 +2421,7 @@ def connect_head_namespaced_service_proxy_with_path(self, name, namespace, path, >>> thread = api.connect_head_namespaced_service_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -2449,7 +2449,7 @@ def connect_head_namespaced_service_proxy_with_path_with_http_info(self, name, n >>> thread = api.connect_head_namespaced_service_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -2558,7 +2558,7 @@ def connect_head_node_proxy(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_head_node_proxy(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -2584,7 +2584,7 @@ def connect_head_node_proxy_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_head_node_proxy_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _return_http_data_only: response data without head status code @@ -2677,7 +2677,7 @@ def connect_head_node_proxy_with_path(self, name, path, **kwargs): # noqa: E501 >>> thread = api.connect_head_node_proxy_with_path(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -2704,7 +2704,7 @@ def connect_head_node_proxy_with_path_with_http_info(self, name, path, **kwargs) >>> thread = api.connect_head_node_proxy_with_path_with_http_info(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -2805,7 +2805,7 @@ def connect_options_namespaced_pod_proxy(self, name, namespace, **kwargs): # no >>> thread = api.connect_options_namespaced_pod_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -2832,7 +2832,7 @@ def connect_options_namespaced_pod_proxy_with_http_info(self, name, namespace, * >>> thread = api.connect_options_namespaced_pod_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -2933,7 +2933,7 @@ def connect_options_namespaced_pod_proxy_with_path(self, name, namespace, path, >>> thread = api.connect_options_namespaced_pod_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -2961,7 +2961,7 @@ def connect_options_namespaced_pod_proxy_with_path_with_http_info(self, name, na >>> thread = api.connect_options_namespaced_pod_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -3070,7 +3070,7 @@ def connect_options_namespaced_service_proxy(self, name, namespace, **kwargs): >>> thread = api.connect_options_namespaced_service_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -3097,7 +3097,7 @@ def connect_options_namespaced_service_proxy_with_http_info(self, name, namespac >>> thread = api.connect_options_namespaced_service_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -3198,7 +3198,7 @@ def connect_options_namespaced_service_proxy_with_path(self, name, namespace, pa >>> thread = api.connect_options_namespaced_service_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -3226,7 +3226,7 @@ def connect_options_namespaced_service_proxy_with_path_with_http_info(self, name >>> thread = api.connect_options_namespaced_service_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -3335,7 +3335,7 @@ def connect_options_node_proxy(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_options_node_proxy(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -3361,7 +3361,7 @@ def connect_options_node_proxy_with_http_info(self, name, **kwargs): # noqa: E5 >>> thread = api.connect_options_node_proxy_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _return_http_data_only: response data without head status code @@ -3454,7 +3454,7 @@ def connect_options_node_proxy_with_path(self, name, path, **kwargs): # noqa: E >>> thread = api.connect_options_node_proxy_with_path(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -3481,7 +3481,7 @@ def connect_options_node_proxy_with_path_with_http_info(self, name, path, **kwar >>> thread = api.connect_options_node_proxy_with_path_with_http_info(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -3582,7 +3582,7 @@ def connect_patch_namespaced_pod_proxy(self, name, namespace, **kwargs): # noqa >>> thread = api.connect_patch_namespaced_pod_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -3609,7 +3609,7 @@ def connect_patch_namespaced_pod_proxy_with_http_info(self, name, namespace, **k >>> thread = api.connect_patch_namespaced_pod_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -3710,7 +3710,7 @@ def connect_patch_namespaced_pod_proxy_with_path(self, name, namespace, path, ** >>> thread = api.connect_patch_namespaced_pod_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -3738,7 +3738,7 @@ def connect_patch_namespaced_pod_proxy_with_path_with_http_info(self, name, name >>> thread = api.connect_patch_namespaced_pod_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -3847,7 +3847,7 @@ def connect_patch_namespaced_service_proxy(self, name, namespace, **kwargs): # >>> thread = api.connect_patch_namespaced_service_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -3874,7 +3874,7 @@ def connect_patch_namespaced_service_proxy_with_http_info(self, name, namespace, >>> thread = api.connect_patch_namespaced_service_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -3975,7 +3975,7 @@ def connect_patch_namespaced_service_proxy_with_path(self, name, namespace, path >>> thread = api.connect_patch_namespaced_service_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -4003,7 +4003,7 @@ def connect_patch_namespaced_service_proxy_with_path_with_http_info(self, name, >>> thread = api.connect_patch_namespaced_service_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -4112,7 +4112,7 @@ def connect_patch_node_proxy(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_patch_node_proxy(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -4138,7 +4138,7 @@ def connect_patch_node_proxy_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_patch_node_proxy_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _return_http_data_only: response data without head status code @@ -4231,7 +4231,7 @@ def connect_patch_node_proxy_with_path(self, name, path, **kwargs): # noqa: E50 >>> thread = api.connect_patch_node_proxy_with_path(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -4258,7 +4258,7 @@ def connect_patch_node_proxy_with_path_with_http_info(self, name, path, **kwargs >>> thread = api.connect_patch_node_proxy_with_path_with_http_info(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -4359,7 +4359,7 @@ def connect_post_namespaced_pod_attach(self, name, namespace, **kwargs): # noqa >>> thread = api.connect_post_namespaced_pod_attach(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodAttachOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str container: The container in which to execute the command. Defaults to only container if there is only one container in the pod. @@ -4390,7 +4390,7 @@ def connect_post_namespaced_pod_attach_with_http_info(self, name, namespace, **k >>> thread = api.connect_post_namespaced_pod_attach_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodAttachOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str container: The container in which to execute the command. Defaults to only container if there is only one container in the pod. @@ -4507,7 +4507,7 @@ def connect_post_namespaced_pod_exec(self, name, namespace, **kwargs): # noqa: >>> thread = api.connect_post_namespaced_pod_exec(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodExecOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str command: Command is the remote command to execute. argv array. Not executed within a shell. @@ -4539,7 +4539,7 @@ def connect_post_namespaced_pod_exec_with_http_info(self, name, namespace, **kwa >>> thread = api.connect_post_namespaced_pod_exec_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodExecOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str command: Command is the remote command to execute. argv array. Not executed within a shell. @@ -4660,7 +4660,7 @@ def connect_post_namespaced_pod_portforward(self, name, namespace, **kwargs): # >>> thread = api.connect_post_namespaced_pod_portforward(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodPortForwardOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param int ports: List of ports to forward Required when using WebSockets @@ -4687,7 +4687,7 @@ def connect_post_namespaced_pod_portforward_with_http_info(self, name, namespace >>> thread = api.connect_post_namespaced_pod_portforward_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodPortForwardOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param int ports: List of ports to forward Required when using WebSockets @@ -4788,7 +4788,7 @@ def connect_post_namespaced_pod_proxy(self, name, namespace, **kwargs): # noqa: >>> thread = api.connect_post_namespaced_pod_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -4815,7 +4815,7 @@ def connect_post_namespaced_pod_proxy_with_http_info(self, name, namespace, **kw >>> thread = api.connect_post_namespaced_pod_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -4916,7 +4916,7 @@ def connect_post_namespaced_pod_proxy_with_path(self, name, namespace, path, **k >>> thread = api.connect_post_namespaced_pod_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -4944,7 +4944,7 @@ def connect_post_namespaced_pod_proxy_with_path_with_http_info(self, name, names >>> thread = api.connect_post_namespaced_pod_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -5053,7 +5053,7 @@ def connect_post_namespaced_service_proxy(self, name, namespace, **kwargs): # n >>> thread = api.connect_post_namespaced_service_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -5080,7 +5080,7 @@ def connect_post_namespaced_service_proxy_with_http_info(self, name, namespace, >>> thread = api.connect_post_namespaced_service_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -5181,7 +5181,7 @@ def connect_post_namespaced_service_proxy_with_path(self, name, namespace, path, >>> thread = api.connect_post_namespaced_service_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -5209,7 +5209,7 @@ def connect_post_namespaced_service_proxy_with_path_with_http_info(self, name, n >>> thread = api.connect_post_namespaced_service_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -5318,7 +5318,7 @@ def connect_post_node_proxy(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_post_node_proxy(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -5344,7 +5344,7 @@ def connect_post_node_proxy_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_post_node_proxy_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _return_http_data_only: response data without head status code @@ -5437,7 +5437,7 @@ def connect_post_node_proxy_with_path(self, name, path, **kwargs): # noqa: E501 >>> thread = api.connect_post_node_proxy_with_path(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -5464,7 +5464,7 @@ def connect_post_node_proxy_with_path_with_http_info(self, name, path, **kwargs) >>> thread = api.connect_post_node_proxy_with_path_with_http_info(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -5565,7 +5565,7 @@ def connect_put_namespaced_pod_proxy(self, name, namespace, **kwargs): # noqa: >>> thread = api.connect_put_namespaced_pod_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -5592,7 +5592,7 @@ def connect_put_namespaced_pod_proxy_with_http_info(self, name, namespace, **kwa >>> thread = api.connect_put_namespaced_pod_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the URL path to use for the current proxy request to pod. @@ -5693,7 +5693,7 @@ def connect_put_namespaced_pod_proxy_with_path(self, name, namespace, path, **kw >>> thread = api.connect_put_namespaced_pod_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -5721,7 +5721,7 @@ def connect_put_namespaced_pod_proxy_with_path_with_http_info(self, name, namesp >>> thread = api.connect_put_namespaced_pod_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -5830,7 +5830,7 @@ def connect_put_namespaced_service_proxy(self, name, namespace, **kwargs): # no >>> thread = api.connect_put_namespaced_service_proxy(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -5857,7 +5857,7 @@ def connect_put_namespaced_service_proxy_with_http_info(self, name, namespace, * >>> thread = api.connect_put_namespaced_service_proxy_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: Path is the part of URLs that include service endpoints, suffixes, and parameters to use for the current proxy request to service. For example, the whole request URL is http://localhost/api/v1/namespaces/kube-system/services/elasticsearch-logging/_search?q=user:kimchy. Path is _search?q=user:kimchy. @@ -5958,7 +5958,7 @@ def connect_put_namespaced_service_proxy_with_path(self, name, namespace, path, >>> thread = api.connect_put_namespaced_service_proxy_with_path(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -5986,7 +5986,7 @@ def connect_put_namespaced_service_proxy_with_path_with_http_info(self, name, na >>> thread = api.connect_put_namespaced_service_proxy_with_path_with_http_info(name, namespace, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceProxyOptions (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str path: path to the resource (required) @@ -6095,7 +6095,7 @@ def connect_put_node_proxy(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_put_node_proxy(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -6121,7 +6121,7 @@ def connect_put_node_proxy_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.connect_put_node_proxy_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: Path is the URL path to use for the current proxy request to node. :param _return_http_data_only: response data without head status code @@ -6214,7 +6214,7 @@ def connect_put_node_proxy_with_path(self, name, path, **kwargs): # noqa: E501 >>> thread = api.connect_put_node_proxy_with_path(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -6241,7 +6241,7 @@ def connect_put_node_proxy_with_path_with_http_info(self, name, path, **kwargs): >>> thread = api.connect_put_node_proxy_with_path_with_http_info(name, path, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the NodeProxyOptions (required) :param str path: path to the resource (required) :param str path2: Path is the URL path to use for the current proxy request to node. @@ -6342,7 +6342,7 @@ def create_namespace(self, body, **kwargs): # noqa: E501 >>> thread = api.create_namespace(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param V1Namespace body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -6371,7 +6371,7 @@ def create_namespace_with_http_info(self, body, **kwargs): # noqa: E501 >>> thread = api.create_namespace_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param V1Namespace body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -6476,7 +6476,7 @@ def create_namespaced_binding(self, namespace, body, **kwargs): # noqa: E501 >>> thread = api.create_namespaced_binding(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Binding body: (required) :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -6506,7 +6506,7 @@ def create_namespaced_binding_with_http_info(self, namespace, body, **kwargs): >>> thread = api.create_namespaced_binding_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Binding body: (required) :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -6619,7 +6619,7 @@ def create_namespaced_config_map(self, namespace, body, **kwargs): # noqa: E501 >>> thread = api.create_namespaced_config_map(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ConfigMap body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -6649,7 +6649,7 @@ def create_namespaced_config_map_with_http_info(self, namespace, body, **kwargs) >>> thread = api.create_namespaced_config_map_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ConfigMap body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -6762,7 +6762,7 @@ def create_namespaced_endpoints(self, namespace, body, **kwargs): # noqa: E501 >>> thread = api.create_namespaced_endpoints(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Endpoints body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -6792,7 +6792,7 @@ def create_namespaced_endpoints_with_http_info(self, namespace, body, **kwargs): >>> thread = api.create_namespaced_endpoints_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Endpoints body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -6905,7 +6905,7 @@ def create_namespaced_event(self, namespace, body, **kwargs): # noqa: E501 >>> thread = api.create_namespaced_event(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param CoreV1Event body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -6935,7 +6935,7 @@ def create_namespaced_event_with_http_info(self, namespace, body, **kwargs): # >>> thread = api.create_namespaced_event_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param CoreV1Event body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -7048,7 +7048,7 @@ def create_namespaced_limit_range(self, namespace, body, **kwargs): # noqa: E50 >>> thread = api.create_namespaced_limit_range(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1LimitRange body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -7078,7 +7078,7 @@ def create_namespaced_limit_range_with_http_info(self, namespace, body, **kwargs >>> thread = api.create_namespaced_limit_range_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1LimitRange body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -7191,7 +7191,7 @@ def create_namespaced_persistent_volume_claim(self, namespace, body, **kwargs): >>> thread = api.create_namespaced_persistent_volume_claim(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1PersistentVolumeClaim body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -7221,7 +7221,7 @@ def create_namespaced_persistent_volume_claim_with_http_info(self, namespace, bo >>> thread = api.create_namespaced_persistent_volume_claim_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1PersistentVolumeClaim body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -7334,7 +7334,7 @@ def create_namespaced_pod(self, namespace, body, **kwargs): # noqa: E501 >>> thread = api.create_namespaced_pod(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Pod body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -7364,7 +7364,7 @@ def create_namespaced_pod_with_http_info(self, namespace, body, **kwargs): # no >>> thread = api.create_namespaced_pod_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Pod body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -7477,7 +7477,7 @@ def create_namespaced_pod_binding(self, name, namespace, body, **kwargs): # noq >>> thread = api.create_namespaced_pod_binding(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Binding (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Binding body: (required) @@ -7508,7 +7508,7 @@ def create_namespaced_pod_binding_with_http_info(self, name, namespace, body, ** >>> thread = api.create_namespaced_pod_binding_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Binding (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Binding body: (required) @@ -7629,7 +7629,7 @@ def create_namespaced_pod_eviction(self, name, namespace, body, **kwargs): # no >>> thread = api.create_namespaced_pod_eviction(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Eviction (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Eviction body: (required) @@ -7660,7 +7660,7 @@ def create_namespaced_pod_eviction_with_http_info(self, name, namespace, body, * >>> thread = api.create_namespaced_pod_eviction_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Eviction (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Eviction body: (required) @@ -7781,7 +7781,7 @@ def create_namespaced_pod_template(self, namespace, body, **kwargs): # noqa: E5 >>> thread = api.create_namespaced_pod_template(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1PodTemplate body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -7811,7 +7811,7 @@ def create_namespaced_pod_template_with_http_info(self, namespace, body, **kwarg >>> thread = api.create_namespaced_pod_template_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1PodTemplate body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -7924,7 +7924,7 @@ def create_namespaced_replication_controller(self, namespace, body, **kwargs): >>> thread = api.create_namespaced_replication_controller(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ReplicationController body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -7954,7 +7954,7 @@ def create_namespaced_replication_controller_with_http_info(self, namespace, bod >>> thread = api.create_namespaced_replication_controller_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ReplicationController body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -8067,7 +8067,7 @@ def create_namespaced_resource_quota(self, namespace, body, **kwargs): # noqa: >>> thread = api.create_namespaced_resource_quota(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ResourceQuota body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -8097,7 +8097,7 @@ def create_namespaced_resource_quota_with_http_info(self, namespace, body, **kwa >>> thread = api.create_namespaced_resource_quota_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ResourceQuota body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -8210,7 +8210,7 @@ def create_namespaced_secret(self, namespace, body, **kwargs): # noqa: E501 >>> thread = api.create_namespaced_secret(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Secret body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -8240,7 +8240,7 @@ def create_namespaced_secret_with_http_info(self, namespace, body, **kwargs): # >>> thread = api.create_namespaced_secret_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Secret body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -8353,7 +8353,7 @@ def create_namespaced_service(self, namespace, body, **kwargs): # noqa: E501 >>> thread = api.create_namespaced_service(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Service body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -8383,7 +8383,7 @@ def create_namespaced_service_with_http_info(self, namespace, body, **kwargs): >>> thread = api.create_namespaced_service_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Service body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -8496,7 +8496,7 @@ def create_namespaced_service_account(self, namespace, body, **kwargs): # noqa: >>> thread = api.create_namespaced_service_account(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ServiceAccount body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -8526,7 +8526,7 @@ def create_namespaced_service_account_with_http_info(self, namespace, body, **kw >>> thread = api.create_namespaced_service_account_with_http_info(namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ServiceAccount body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -8639,7 +8639,7 @@ def create_namespaced_service_account_token(self, name, namespace, body, **kwarg >>> thread = api.create_namespaced_service_account_token(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the TokenRequest (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param AuthenticationV1TokenRequest body: (required) @@ -8670,7 +8670,7 @@ def create_namespaced_service_account_token_with_http_info(self, name, namespace >>> thread = api.create_namespaced_service_account_token_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the TokenRequest (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param AuthenticationV1TokenRequest body: (required) @@ -8791,7 +8791,7 @@ def create_node(self, body, **kwargs): # noqa: E501 >>> thread = api.create_node(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param V1Node body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -8820,7 +8820,7 @@ def create_node_with_http_info(self, body, **kwargs): # noqa: E501 >>> thread = api.create_node_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param V1Node body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -8925,7 +8925,7 @@ def create_persistent_volume(self, body, **kwargs): # noqa: E501 >>> thread = api.create_persistent_volume(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param V1PersistentVolume body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -8954,7 +8954,7 @@ def create_persistent_volume_with_http_info(self, body, **kwargs): # noqa: E501 >>> thread = api.create_persistent_volume_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param V1PersistentVolume body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -9059,7 +9059,7 @@ def delete_collection_namespaced_config_map(self, namespace, **kwargs): # noqa: >>> thread = api.delete_collection_namespaced_config_map(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -9099,7 +9099,7 @@ def delete_collection_namespaced_config_map_with_http_info(self, namespace, **kw >>> thread = api.delete_collection_namespaced_config_map_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -9248,7 +9248,7 @@ def delete_collection_namespaced_endpoints(self, namespace, **kwargs): # noqa: >>> thread = api.delete_collection_namespaced_endpoints(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -9288,7 +9288,7 @@ def delete_collection_namespaced_endpoints_with_http_info(self, namespace, **kwa >>> thread = api.delete_collection_namespaced_endpoints_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -9437,7 +9437,7 @@ def delete_collection_namespaced_event(self, namespace, **kwargs): # noqa: E501 >>> thread = api.delete_collection_namespaced_event(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -9477,7 +9477,7 @@ def delete_collection_namespaced_event_with_http_info(self, namespace, **kwargs) >>> thread = api.delete_collection_namespaced_event_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -9626,7 +9626,7 @@ def delete_collection_namespaced_limit_range(self, namespace, **kwargs): # noqa >>> thread = api.delete_collection_namespaced_limit_range(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -9666,7 +9666,7 @@ def delete_collection_namespaced_limit_range_with_http_info(self, namespace, **k >>> thread = api.delete_collection_namespaced_limit_range_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -9815,7 +9815,7 @@ def delete_collection_namespaced_persistent_volume_claim(self, namespace, **kwar >>> thread = api.delete_collection_namespaced_persistent_volume_claim(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -9855,7 +9855,7 @@ def delete_collection_namespaced_persistent_volume_claim_with_http_info(self, na >>> thread = api.delete_collection_namespaced_persistent_volume_claim_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10004,7 +10004,7 @@ def delete_collection_namespaced_pod(self, namespace, **kwargs): # noqa: E501 >>> thread = api.delete_collection_namespaced_pod(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10044,7 +10044,7 @@ def delete_collection_namespaced_pod_with_http_info(self, namespace, **kwargs): >>> thread = api.delete_collection_namespaced_pod_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10193,7 +10193,7 @@ def delete_collection_namespaced_pod_template(self, namespace, **kwargs): # noq >>> thread = api.delete_collection_namespaced_pod_template(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10233,7 +10233,7 @@ def delete_collection_namespaced_pod_template_with_http_info(self, namespace, ** >>> thread = api.delete_collection_namespaced_pod_template_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10382,7 +10382,7 @@ def delete_collection_namespaced_replication_controller(self, namespace, **kwarg >>> thread = api.delete_collection_namespaced_replication_controller(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10422,7 +10422,7 @@ def delete_collection_namespaced_replication_controller_with_http_info(self, nam >>> thread = api.delete_collection_namespaced_replication_controller_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10571,7 +10571,7 @@ def delete_collection_namespaced_resource_quota(self, namespace, **kwargs): # n >>> thread = api.delete_collection_namespaced_resource_quota(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10611,7 +10611,7 @@ def delete_collection_namespaced_resource_quota_with_http_info(self, namespace, >>> thread = api.delete_collection_namespaced_resource_quota_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10760,7 +10760,7 @@ def delete_collection_namespaced_secret(self, namespace, **kwargs): # noqa: E50 >>> thread = api.delete_collection_namespaced_secret(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10800,7 +10800,7 @@ def delete_collection_namespaced_secret_with_http_info(self, namespace, **kwargs >>> thread = api.delete_collection_namespaced_secret_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10949,7 +10949,7 @@ def delete_collection_namespaced_service(self, namespace, **kwargs): # noqa: E5 >>> thread = api.delete_collection_namespaced_service(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -10989,7 +10989,7 @@ def delete_collection_namespaced_service_with_http_info(self, namespace, **kwarg >>> thread = api.delete_collection_namespaced_service_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -11138,7 +11138,7 @@ def delete_collection_namespaced_service_account(self, namespace, **kwargs): # >>> thread = api.delete_collection_namespaced_service_account(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -11178,7 +11178,7 @@ def delete_collection_namespaced_service_account_with_http_info(self, namespace, >>> thread = api.delete_collection_namespaced_service_account_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -11327,7 +11327,7 @@ def delete_collection_node(self, **kwargs): # noqa: E501 >>> thread = api.delete_collection_node(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -11366,7 +11366,7 @@ def delete_collection_node_with_http_info(self, **kwargs): # noqa: E501 >>> thread = api.delete_collection_node_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -11507,7 +11507,7 @@ def delete_collection_persistent_volume(self, **kwargs): # noqa: E501 >>> thread = api.delete_collection_persistent_volume(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -11546,7 +11546,7 @@ def delete_collection_persistent_volume_with_http_info(self, **kwargs): # noqa: >>> thread = api.delete_collection_persistent_volume_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -11687,7 +11687,7 @@ def delete_namespace(self, name, **kwargs): # noqa: E501 >>> thread = api.delete_namespace(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -11719,7 +11719,7 @@ def delete_namespace_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.delete_namespace_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -11836,7 +11836,7 @@ def delete_namespaced_config_map(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.delete_namespaced_config_map(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ConfigMap (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -11869,7 +11869,7 @@ def delete_namespaced_config_map_with_http_info(self, name, namespace, **kwargs) >>> thread = api.delete_namespaced_config_map_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ConfigMap (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -11994,7 +11994,7 @@ def delete_namespaced_endpoints(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.delete_namespaced_endpoints(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Endpoints (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12027,7 +12027,7 @@ def delete_namespaced_endpoints_with_http_info(self, name, namespace, **kwargs): >>> thread = api.delete_namespaced_endpoints_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Endpoints (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12152,7 +12152,7 @@ def delete_namespaced_event(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.delete_namespaced_event(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Event (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12185,7 +12185,7 @@ def delete_namespaced_event_with_http_info(self, name, namespace, **kwargs): # >>> thread = api.delete_namespaced_event_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Event (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12310,7 +12310,7 @@ def delete_namespaced_limit_range(self, name, namespace, **kwargs): # noqa: E50 >>> thread = api.delete_namespaced_limit_range(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the LimitRange (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12343,7 +12343,7 @@ def delete_namespaced_limit_range_with_http_info(self, name, namespace, **kwargs >>> thread = api.delete_namespaced_limit_range_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the LimitRange (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12468,7 +12468,7 @@ def delete_namespaced_persistent_volume_claim(self, name, namespace, **kwargs): >>> thread = api.delete_namespaced_persistent_volume_claim(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12501,7 +12501,7 @@ def delete_namespaced_persistent_volume_claim_with_http_info(self, name, namespa >>> thread = api.delete_namespaced_persistent_volume_claim_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12626,7 +12626,7 @@ def delete_namespaced_pod(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.delete_namespaced_pod(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12659,7 +12659,7 @@ def delete_namespaced_pod_with_http_info(self, name, namespace, **kwargs): # no >>> thread = api.delete_namespaced_pod_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12784,7 +12784,7 @@ def delete_namespaced_pod_template(self, name, namespace, **kwargs): # noqa: E5 >>> thread = api.delete_namespaced_pod_template(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodTemplate (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12817,7 +12817,7 @@ def delete_namespaced_pod_template_with_http_info(self, name, namespace, **kwarg >>> thread = api.delete_namespaced_pod_template_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodTemplate (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12942,7 +12942,7 @@ def delete_namespaced_replication_controller(self, name, namespace, **kwargs): >>> thread = api.delete_namespaced_replication_controller(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -12975,7 +12975,7 @@ def delete_namespaced_replication_controller_with_http_info(self, name, namespac >>> thread = api.delete_namespaced_replication_controller_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -13100,7 +13100,7 @@ def delete_namespaced_resource_quota(self, name, namespace, **kwargs): # noqa: >>> thread = api.delete_namespaced_resource_quota(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -13133,7 +13133,7 @@ def delete_namespaced_resource_quota_with_http_info(self, name, namespace, **kwa >>> thread = api.delete_namespaced_resource_quota_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -13258,7 +13258,7 @@ def delete_namespaced_secret(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.delete_namespaced_secret(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Secret (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -13291,7 +13291,7 @@ def delete_namespaced_secret_with_http_info(self, name, namespace, **kwargs): # >>> thread = api.delete_namespaced_secret_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Secret (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -13416,7 +13416,7 @@ def delete_namespaced_service(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.delete_namespaced_service(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -13449,7 +13449,7 @@ def delete_namespaced_service_with_http_info(self, name, namespace, **kwargs): >>> thread = api.delete_namespaced_service_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -13574,7 +13574,7 @@ def delete_namespaced_service_account(self, name, namespace, **kwargs): # noqa: >>> thread = api.delete_namespaced_service_account(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceAccount (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -13607,7 +13607,7 @@ def delete_namespaced_service_account_with_http_info(self, name, namespace, **kw >>> thread = api.delete_namespaced_service_account_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceAccount (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -13732,7 +13732,7 @@ def delete_node(self, name, **kwargs): # noqa: E501 >>> thread = api.delete_node(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -13764,7 +13764,7 @@ def delete_node_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.delete_node_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -13881,7 +13881,7 @@ def delete_persistent_volume(self, name, **kwargs): # noqa: E501 >>> thread = api.delete_persistent_volume(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -13913,7 +13913,7 @@ def delete_persistent_volume_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.delete_persistent_volume_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -14030,7 +14030,7 @@ def get_api_resources(self, **kwargs): # noqa: E501 >>> thread = api.get_api_resources(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. @@ -14054,7 +14054,7 @@ def get_api_resources_with_http_info(self, **kwargs): # noqa: E501 >>> thread = api.get_api_resources_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -14135,7 +14135,7 @@ def list_component_status(self, **kwargs): # noqa: E501 >>> thread = api.list_component_status(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -14170,7 +14170,7 @@ def list_component_status_with_http_info(self, **kwargs): # noqa: E501 >>> thread = api.list_component_status_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -14295,7 +14295,7 @@ def list_config_map_for_all_namespaces(self, **kwargs): # noqa: E501 >>> thread = api.list_config_map_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -14330,7 +14330,7 @@ def list_config_map_for_all_namespaces_with_http_info(self, **kwargs): # noqa: >>> thread = api.list_config_map_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -14455,7 +14455,7 @@ def list_endpoints_for_all_namespaces(self, **kwargs): # noqa: E501 >>> thread = api.list_endpoints_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -14490,7 +14490,7 @@ def list_endpoints_for_all_namespaces_with_http_info(self, **kwargs): # noqa: E >>> thread = api.list_endpoints_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -14615,7 +14615,7 @@ def list_event_for_all_namespaces(self, **kwargs): # noqa: E501 >>> thread = api.list_event_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -14650,7 +14650,7 @@ def list_event_for_all_namespaces_with_http_info(self, **kwargs): # noqa: E501 >>> thread = api.list_event_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -14775,7 +14775,7 @@ def list_limit_range_for_all_namespaces(self, **kwargs): # noqa: E501 >>> thread = api.list_limit_range_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -14810,7 +14810,7 @@ def list_limit_range_for_all_namespaces_with_http_info(self, **kwargs): # noqa: >>> thread = api.list_limit_range_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -14935,7 +14935,7 @@ def list_namespace(self, **kwargs): # noqa: E501 >>> thread = api.list_namespace(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -14970,7 +14970,7 @@ def list_namespace_with_http_info(self, **kwargs): # noqa: E501 >>> thread = api.list_namespace_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -15095,7 +15095,7 @@ def list_namespaced_config_map(self, namespace, **kwargs): # noqa: E501 >>> thread = api.list_namespaced_config_map(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -15131,7 +15131,7 @@ def list_namespaced_config_map_with_http_info(self, namespace, **kwargs): # noq >>> thread = api.list_namespaced_config_map_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -15264,7 +15264,7 @@ def list_namespaced_endpoints(self, namespace, **kwargs): # noqa: E501 >>> thread = api.list_namespaced_endpoints(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -15300,7 +15300,7 @@ def list_namespaced_endpoints_with_http_info(self, namespace, **kwargs): # noqa >>> thread = api.list_namespaced_endpoints_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -15433,7 +15433,7 @@ def list_namespaced_event(self, namespace, **kwargs): # noqa: E501 >>> thread = api.list_namespaced_event(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -15469,7 +15469,7 @@ def list_namespaced_event_with_http_info(self, namespace, **kwargs): # noqa: E5 >>> thread = api.list_namespaced_event_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -15602,7 +15602,7 @@ def list_namespaced_limit_range(self, namespace, **kwargs): # noqa: E501 >>> thread = api.list_namespaced_limit_range(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -15638,7 +15638,7 @@ def list_namespaced_limit_range_with_http_info(self, namespace, **kwargs): # no >>> thread = api.list_namespaced_limit_range_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -15771,7 +15771,7 @@ def list_namespaced_persistent_volume_claim(self, namespace, **kwargs): # noqa: >>> thread = api.list_namespaced_persistent_volume_claim(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -15807,7 +15807,7 @@ def list_namespaced_persistent_volume_claim_with_http_info(self, namespace, **kw >>> thread = api.list_namespaced_persistent_volume_claim_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -15976,7 +15976,7 @@ def list_namespaced_pod_with_http_info(self, namespace, **kwargs): # noqa: E501 >>> thread = api.list_namespaced_pod_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16109,7 +16109,7 @@ def list_namespaced_pod_template(self, namespace, **kwargs): # noqa: E501 >>> thread = api.list_namespaced_pod_template(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16145,7 +16145,7 @@ def list_namespaced_pod_template_with_http_info(self, namespace, **kwargs): # n >>> thread = api.list_namespaced_pod_template_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16278,7 +16278,7 @@ def list_namespaced_replication_controller(self, namespace, **kwargs): # noqa: >>> thread = api.list_namespaced_replication_controller(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16314,7 +16314,7 @@ def list_namespaced_replication_controller_with_http_info(self, namespace, **kwa >>> thread = api.list_namespaced_replication_controller_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16447,7 +16447,7 @@ def list_namespaced_resource_quota(self, namespace, **kwargs): # noqa: E501 >>> thread = api.list_namespaced_resource_quota(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16483,7 +16483,7 @@ def list_namespaced_resource_quota_with_http_info(self, namespace, **kwargs): # >>> thread = api.list_namespaced_resource_quota_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16616,7 +16616,7 @@ def list_namespaced_secret(self, namespace, **kwargs): # noqa: E501 >>> thread = api.list_namespaced_secret(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16652,7 +16652,7 @@ def list_namespaced_secret_with_http_info(self, namespace, **kwargs): # noqa: E >>> thread = api.list_namespaced_secret_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16785,7 +16785,7 @@ def list_namespaced_service(self, namespace, **kwargs): # noqa: E501 >>> thread = api.list_namespaced_service(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16821,7 +16821,7 @@ def list_namespaced_service_with_http_info(self, namespace, **kwargs): # noqa: >>> thread = api.list_namespaced_service_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16954,7 +16954,7 @@ def list_namespaced_service_account(self, namespace, **kwargs): # noqa: E501 >>> thread = api.list_namespaced_service_account(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -16990,7 +16990,7 @@ def list_namespaced_service_account_with_http_info(self, namespace, **kwargs): >>> thread = api.list_namespaced_service_account_with_http_info(namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. @@ -17123,7 +17123,7 @@ def list_node(self, **kwargs): # noqa: E501 >>> thread = api.list_node(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -17158,7 +17158,7 @@ def list_node_with_http_info(self, **kwargs): # noqa: E501 >>> thread = api.list_node_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -17283,7 +17283,7 @@ def list_persistent_volume(self, **kwargs): # noqa: E501 >>> thread = api.list_persistent_volume(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -17318,7 +17318,7 @@ def list_persistent_volume_with_http_info(self, **kwargs): # noqa: E501 >>> thread = api.list_persistent_volume_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. @@ -17443,7 +17443,7 @@ def list_persistent_volume_claim_for_all_namespaces(self, **kwargs): # noqa: E5 >>> thread = api.list_persistent_volume_claim_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -17478,7 +17478,7 @@ def list_persistent_volume_claim_for_all_namespaces_with_http_info(self, **kwarg >>> thread = api.list_persistent_volume_claim_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -17603,7 +17603,7 @@ def list_pod_for_all_namespaces(self, **kwargs): # noqa: E501 >>> thread = api.list_pod_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -17638,7 +17638,7 @@ def list_pod_for_all_namespaces_with_http_info(self, **kwargs): # noqa: E501 >>> thread = api.list_pod_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -17763,7 +17763,7 @@ def list_pod_template_for_all_namespaces(self, **kwargs): # noqa: E501 >>> thread = api.list_pod_template_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -17798,7 +17798,7 @@ def list_pod_template_for_all_namespaces_with_http_info(self, **kwargs): # noqa >>> thread = api.list_pod_template_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -17923,7 +17923,7 @@ def list_replication_controller_for_all_namespaces(self, **kwargs): # noqa: E50 >>> thread = api.list_replication_controller_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -17958,7 +17958,7 @@ def list_replication_controller_for_all_namespaces_with_http_info(self, **kwargs >>> thread = api.list_replication_controller_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -18083,7 +18083,7 @@ def list_resource_quota_for_all_namespaces(self, **kwargs): # noqa: E501 >>> thread = api.list_resource_quota_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -18118,7 +18118,7 @@ def list_resource_quota_for_all_namespaces_with_http_info(self, **kwargs): # no >>> thread = api.list_resource_quota_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -18243,7 +18243,7 @@ def list_secret_for_all_namespaces(self, **kwargs): # noqa: E501 >>> thread = api.list_secret_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -18278,7 +18278,7 @@ def list_secret_for_all_namespaces_with_http_info(self, **kwargs): # noqa: E501 >>> thread = api.list_secret_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -18403,7 +18403,7 @@ def list_service_account_for_all_namespaces(self, **kwargs): # noqa: E501 >>> thread = api.list_service_account_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -18438,7 +18438,7 @@ def list_service_account_for_all_namespaces_with_http_info(self, **kwargs): # n >>> thread = api.list_service_account_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -18563,7 +18563,7 @@ def list_service_for_all_namespaces(self, **kwargs): # noqa: E501 >>> thread = api.list_service_for_all_namespaces(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -18598,7 +18598,7 @@ def list_service_for_all_namespaces_with_http_info(self, **kwargs): # noqa: E50 >>> thread = api.list_service_for_all_namespaces_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param bool allow_watch_bookmarks: allowWatchBookmarks requests watch events with type \"BOOKMARK\". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. :param str _continue: The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the \"next key\". This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications. :param str field_selector: A selector to restrict the list of returned objects by their fields. Defaults to everything. @@ -18723,7 +18723,7 @@ def patch_namespace(self, name, body, **kwargs): # noqa: E501 >>> thread = api.patch_namespace(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -18754,7 +18754,7 @@ def patch_namespace_with_http_info(self, name, body, **kwargs): # noqa: E501 >>> thread = api.patch_namespace_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -18875,7 +18875,7 @@ def patch_namespace_status(self, name, body, **kwargs): # noqa: E501 >>> thread = api.patch_namespace_status(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -18906,7 +18906,7 @@ def patch_namespace_status_with_http_info(self, name, body, **kwargs): # noqa: >>> thread = api.patch_namespace_status_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -19027,7 +19027,7 @@ def patch_namespaced_config_map(self, name, namespace, body, **kwargs): # noqa: >>> thread = api.patch_namespaced_config_map(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ConfigMap (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19059,7 +19059,7 @@ def patch_namespaced_config_map_with_http_info(self, name, namespace, body, **kw >>> thread = api.patch_namespaced_config_map_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ConfigMap (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19188,7 +19188,7 @@ def patch_namespaced_endpoints(self, name, namespace, body, **kwargs): # noqa: >>> thread = api.patch_namespaced_endpoints(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Endpoints (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19220,7 +19220,7 @@ def patch_namespaced_endpoints_with_http_info(self, name, namespace, body, **kwa >>> thread = api.patch_namespaced_endpoints_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Endpoints (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19349,7 +19349,7 @@ def patch_namespaced_event(self, name, namespace, body, **kwargs): # noqa: E501 >>> thread = api.patch_namespaced_event(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Event (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19381,7 +19381,7 @@ def patch_namespaced_event_with_http_info(self, name, namespace, body, **kwargs) >>> thread = api.patch_namespaced_event_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Event (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19510,7 +19510,7 @@ def patch_namespaced_limit_range(self, name, namespace, body, **kwargs): # noqa >>> thread = api.patch_namespaced_limit_range(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the LimitRange (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19542,7 +19542,7 @@ def patch_namespaced_limit_range_with_http_info(self, name, namespace, body, **k >>> thread = api.patch_namespaced_limit_range_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the LimitRange (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19671,7 +19671,7 @@ def patch_namespaced_persistent_volume_claim(self, name, namespace, body, **kwar >>> thread = api.patch_namespaced_persistent_volume_claim(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19703,7 +19703,7 @@ def patch_namespaced_persistent_volume_claim_with_http_info(self, name, namespac >>> thread = api.patch_namespaced_persistent_volume_claim_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19832,7 +19832,7 @@ def patch_namespaced_persistent_volume_claim_status(self, name, namespace, body, >>> thread = api.patch_namespaced_persistent_volume_claim_status(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19864,7 +19864,7 @@ def patch_namespaced_persistent_volume_claim_status_with_http_info(self, name, n >>> thread = api.patch_namespaced_persistent_volume_claim_status_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -19993,7 +19993,7 @@ def patch_namespaced_pod(self, name, namespace, body, **kwargs): # noqa: E501 >>> thread = api.patch_namespaced_pod(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20025,7 +20025,7 @@ def patch_namespaced_pod_with_http_info(self, name, namespace, body, **kwargs): >>> thread = api.patch_namespaced_pod_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20154,7 +20154,7 @@ def patch_namespaced_pod_ephemeralcontainers(self, name, namespace, body, **kwar >>> thread = api.patch_namespaced_pod_ephemeralcontainers(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20186,7 +20186,7 @@ def patch_namespaced_pod_ephemeralcontainers_with_http_info(self, name, namespac >>> thread = api.patch_namespaced_pod_ephemeralcontainers_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20315,7 +20315,7 @@ def patch_namespaced_pod_resize(self, name, namespace, body, **kwargs): # noqa: >>> thread = api.patch_namespaced_pod_resize(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20347,7 +20347,7 @@ def patch_namespaced_pod_resize_with_http_info(self, name, namespace, body, **kw >>> thread = api.patch_namespaced_pod_resize_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20476,7 +20476,7 @@ def patch_namespaced_pod_status(self, name, namespace, body, **kwargs): # noqa: >>> thread = api.patch_namespaced_pod_status(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20508,7 +20508,7 @@ def patch_namespaced_pod_status_with_http_info(self, name, namespace, body, **kw >>> thread = api.patch_namespaced_pod_status_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20637,7 +20637,7 @@ def patch_namespaced_pod_template(self, name, namespace, body, **kwargs): # noq >>> thread = api.patch_namespaced_pod_template(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodTemplate (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20669,7 +20669,7 @@ def patch_namespaced_pod_template_with_http_info(self, name, namespace, body, ** >>> thread = api.patch_namespaced_pod_template_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodTemplate (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20798,7 +20798,7 @@ def patch_namespaced_replication_controller(self, name, namespace, body, **kwarg >>> thread = api.patch_namespaced_replication_controller(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20830,7 +20830,7 @@ def patch_namespaced_replication_controller_with_http_info(self, name, namespace >>> thread = api.patch_namespaced_replication_controller_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20959,7 +20959,7 @@ def patch_namespaced_replication_controller_scale(self, name, namespace, body, * >>> thread = api.patch_namespaced_replication_controller_scale(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Scale (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -20991,7 +20991,7 @@ def patch_namespaced_replication_controller_scale_with_http_info(self, name, nam >>> thread = api.patch_namespaced_replication_controller_scale_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Scale (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21120,7 +21120,7 @@ def patch_namespaced_replication_controller_status(self, name, namespace, body, >>> thread = api.patch_namespaced_replication_controller_status(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21152,7 +21152,7 @@ def patch_namespaced_replication_controller_status_with_http_info(self, name, na >>> thread = api.patch_namespaced_replication_controller_status_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21281,7 +21281,7 @@ def patch_namespaced_resource_quota(self, name, namespace, body, **kwargs): # n >>> thread = api.patch_namespaced_resource_quota(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21313,7 +21313,7 @@ def patch_namespaced_resource_quota_with_http_info(self, name, namespace, body, >>> thread = api.patch_namespaced_resource_quota_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21442,7 +21442,7 @@ def patch_namespaced_resource_quota_status(self, name, namespace, body, **kwargs >>> thread = api.patch_namespaced_resource_quota_status(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21474,7 +21474,7 @@ def patch_namespaced_resource_quota_status_with_http_info(self, name, namespace, >>> thread = api.patch_namespaced_resource_quota_status_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21603,7 +21603,7 @@ def patch_namespaced_secret(self, name, namespace, body, **kwargs): # noqa: E50 >>> thread = api.patch_namespaced_secret(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Secret (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21635,7 +21635,7 @@ def patch_namespaced_secret_with_http_info(self, name, namespace, body, **kwargs >>> thread = api.patch_namespaced_secret_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Secret (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21764,7 +21764,7 @@ def patch_namespaced_service(self, name, namespace, body, **kwargs): # noqa: E5 >>> thread = api.patch_namespaced_service(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21796,7 +21796,7 @@ def patch_namespaced_service_with_http_info(self, name, namespace, body, **kwarg >>> thread = api.patch_namespaced_service_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21925,7 +21925,7 @@ def patch_namespaced_service_account(self, name, namespace, body, **kwargs): # >>> thread = api.patch_namespaced_service_account(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceAccount (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -21957,7 +21957,7 @@ def patch_namespaced_service_account_with_http_info(self, name, namespace, body, >>> thread = api.patch_namespaced_service_account_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceAccount (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -22086,7 +22086,7 @@ def patch_namespaced_service_status(self, name, namespace, body, **kwargs): # n >>> thread = api.patch_namespaced_service_status(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -22118,7 +22118,7 @@ def patch_namespaced_service_status_with_http_info(self, name, namespace, body, >>> thread = api.patch_namespaced_service_status_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param object body: (required) @@ -22247,7 +22247,7 @@ def patch_node(self, name, body, **kwargs): # noqa: E501 >>> thread = api.patch_node(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -22278,7 +22278,7 @@ def patch_node_with_http_info(self, name, body, **kwargs): # noqa: E501 >>> thread = api.patch_node_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -22399,7 +22399,7 @@ def patch_node_status(self, name, body, **kwargs): # noqa: E501 >>> thread = api.patch_node_status(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -22430,7 +22430,7 @@ def patch_node_status_with_http_info(self, name, body, **kwargs): # noqa: E501 >>> thread = api.patch_node_status_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -22551,7 +22551,7 @@ def patch_persistent_volume(self, name, body, **kwargs): # noqa: E501 >>> thread = api.patch_persistent_volume(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -22582,7 +22582,7 @@ def patch_persistent_volume_with_http_info(self, name, body, **kwargs): # noqa: >>> thread = api.patch_persistent_volume_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -22703,7 +22703,7 @@ def patch_persistent_volume_status(self, name, body, **kwargs): # noqa: E501 >>> thread = api.patch_persistent_volume_status(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -22734,7 +22734,7 @@ def patch_persistent_volume_status_with_http_info(self, name, body, **kwargs): >>> thread = api.patch_persistent_volume_status_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param object body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -22855,7 +22855,7 @@ def read_component_status(self, name, **kwargs): # noqa: E501 >>> thread = api.read_component_status(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ComponentStatus (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -22881,7 +22881,7 @@ def read_component_status_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.read_component_status_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ComponentStatus (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _return_http_data_only: response data without head status code @@ -22974,7 +22974,7 @@ def read_namespace(self, name, **kwargs): # noqa: E501 >>> thread = api.read_namespace(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -23000,7 +23000,7 @@ def read_namespace_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.read_namespace_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _return_http_data_only: response data without head status code @@ -23093,7 +23093,7 @@ def read_namespace_status(self, name, **kwargs): # noqa: E501 >>> thread = api.read_namespace_status(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -23119,7 +23119,7 @@ def read_namespace_status_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.read_namespace_status_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _return_http_data_only: response data without head status code @@ -23212,7 +23212,7 @@ def read_namespaced_config_map(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.read_namespaced_config_map(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ConfigMap (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23239,7 +23239,7 @@ def read_namespaced_config_map_with_http_info(self, name, namespace, **kwargs): >>> thread = api.read_namespaced_config_map_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ConfigMap (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23340,7 +23340,7 @@ def read_namespaced_endpoints(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.read_namespaced_endpoints(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Endpoints (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23367,7 +23367,7 @@ def read_namespaced_endpoints_with_http_info(self, name, namespace, **kwargs): >>> thread = api.read_namespaced_endpoints_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Endpoints (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23468,7 +23468,7 @@ def read_namespaced_event(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.read_namespaced_event(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Event (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23495,7 +23495,7 @@ def read_namespaced_event_with_http_info(self, name, namespace, **kwargs): # no >>> thread = api.read_namespaced_event_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Event (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23596,7 +23596,7 @@ def read_namespaced_limit_range(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.read_namespaced_limit_range(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the LimitRange (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23623,7 +23623,7 @@ def read_namespaced_limit_range_with_http_info(self, name, namespace, **kwargs): >>> thread = api.read_namespaced_limit_range_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the LimitRange (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23724,7 +23724,7 @@ def read_namespaced_persistent_volume_claim(self, name, namespace, **kwargs): # >>> thread = api.read_namespaced_persistent_volume_claim(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23751,7 +23751,7 @@ def read_namespaced_persistent_volume_claim_with_http_info(self, name, namespace >>> thread = api.read_namespaced_persistent_volume_claim_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23852,7 +23852,7 @@ def read_namespaced_persistent_volume_claim_status(self, name, namespace, **kwar >>> thread = api.read_namespaced_persistent_volume_claim_status(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23879,7 +23879,7 @@ def read_namespaced_persistent_volume_claim_status_with_http_info(self, name, na >>> thread = api.read_namespaced_persistent_volume_claim_status_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -23980,7 +23980,7 @@ def read_namespaced_pod(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.read_namespaced_pod(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24007,7 +24007,7 @@ def read_namespaced_pod_with_http_info(self, name, namespace, **kwargs): # noqa >>> thread = api.read_namespaced_pod_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24108,7 +24108,7 @@ def read_namespaced_pod_ephemeralcontainers(self, name, namespace, **kwargs): # >>> thread = api.read_namespaced_pod_ephemeralcontainers(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24135,7 +24135,7 @@ def read_namespaced_pod_ephemeralcontainers_with_http_info(self, name, namespace >>> thread = api.read_namespaced_pod_ephemeralcontainers_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24236,7 +24236,7 @@ def read_namespaced_pod_log(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.read_namespaced_pod_log(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str container: The container for which to stream logs. Defaults to only container if there is one container in the pod. @@ -24272,7 +24272,7 @@ def read_namespaced_pod_log_with_http_info(self, name, namespace, **kwargs): # >>> thread = api.read_namespaced_pod_log_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str container: The container for which to stream logs. Defaults to only container if there is one container in the pod. @@ -24409,7 +24409,7 @@ def read_namespaced_pod_resize(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.read_namespaced_pod_resize(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24436,7 +24436,7 @@ def read_namespaced_pod_resize_with_http_info(self, name, namespace, **kwargs): >>> thread = api.read_namespaced_pod_resize_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24537,7 +24537,7 @@ def read_namespaced_pod_status(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.read_namespaced_pod_status(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24564,7 +24564,7 @@ def read_namespaced_pod_status_with_http_info(self, name, namespace, **kwargs): >>> thread = api.read_namespaced_pod_status_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24665,7 +24665,7 @@ def read_namespaced_pod_template(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.read_namespaced_pod_template(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodTemplate (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24692,7 +24692,7 @@ def read_namespaced_pod_template_with_http_info(self, name, namespace, **kwargs) >>> thread = api.read_namespaced_pod_template_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodTemplate (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24793,7 +24793,7 @@ def read_namespaced_replication_controller(self, name, namespace, **kwargs): # >>> thread = api.read_namespaced_replication_controller(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24820,7 +24820,7 @@ def read_namespaced_replication_controller_with_http_info(self, name, namespace, >>> thread = api.read_namespaced_replication_controller_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24921,7 +24921,7 @@ def read_namespaced_replication_controller_scale(self, name, namespace, **kwargs >>> thread = api.read_namespaced_replication_controller_scale(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Scale (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -24948,7 +24948,7 @@ def read_namespaced_replication_controller_scale_with_http_info(self, name, name >>> thread = api.read_namespaced_replication_controller_scale_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Scale (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25049,7 +25049,7 @@ def read_namespaced_replication_controller_status(self, name, namespace, **kwarg >>> thread = api.read_namespaced_replication_controller_status(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25076,7 +25076,7 @@ def read_namespaced_replication_controller_status_with_http_info(self, name, nam >>> thread = api.read_namespaced_replication_controller_status_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25177,7 +25177,7 @@ def read_namespaced_resource_quota(self, name, namespace, **kwargs): # noqa: E5 >>> thread = api.read_namespaced_resource_quota(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25204,7 +25204,7 @@ def read_namespaced_resource_quota_with_http_info(self, name, namespace, **kwarg >>> thread = api.read_namespaced_resource_quota_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25305,7 +25305,7 @@ def read_namespaced_resource_quota_status(self, name, namespace, **kwargs): # n >>> thread = api.read_namespaced_resource_quota_status(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25332,7 +25332,7 @@ def read_namespaced_resource_quota_status_with_http_info(self, name, namespace, >>> thread = api.read_namespaced_resource_quota_status_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25433,7 +25433,7 @@ def read_namespaced_secret(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.read_namespaced_secret(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Secret (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25460,7 +25460,7 @@ def read_namespaced_secret_with_http_info(self, name, namespace, **kwargs): # n >>> thread = api.read_namespaced_secret_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Secret (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25561,7 +25561,7 @@ def read_namespaced_service(self, name, namespace, **kwargs): # noqa: E501 >>> thread = api.read_namespaced_service(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25588,7 +25588,7 @@ def read_namespaced_service_with_http_info(self, name, namespace, **kwargs): # >>> thread = api.read_namespaced_service_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25689,7 +25689,7 @@ def read_namespaced_service_account(self, name, namespace, **kwargs): # noqa: E >>> thread = api.read_namespaced_service_account(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceAccount (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25716,7 +25716,7 @@ def read_namespaced_service_account_with_http_info(self, name, namespace, **kwar >>> thread = api.read_namespaced_service_account_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceAccount (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25817,7 +25817,7 @@ def read_namespaced_service_status(self, name, namespace, **kwargs): # noqa: E5 >>> thread = api.read_namespaced_service_status(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25844,7 +25844,7 @@ def read_namespaced_service_status_with_http_info(self, name, namespace, **kwarg >>> thread = api.read_namespaced_service_status_with_http_info(name, namespace, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -25945,7 +25945,7 @@ def read_node(self, name, **kwargs): # noqa: E501 >>> thread = api.read_node(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -25971,7 +25971,7 @@ def read_node_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.read_node_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _return_http_data_only: response data without head status code @@ -26064,7 +26064,7 @@ def read_node_status(self, name, **kwargs): # noqa: E501 >>> thread = api.read_node_status(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -26090,7 +26090,7 @@ def read_node_status_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.read_node_status_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _return_http_data_only: response data without head status code @@ -26183,7 +26183,7 @@ def read_persistent_volume(self, name, **kwargs): # noqa: E501 >>> thread = api.read_persistent_volume(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -26209,7 +26209,7 @@ def read_persistent_volume_with_http_info(self, name, **kwargs): # noqa: E501 >>> thread = api.read_persistent_volume_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _return_http_data_only: response data without head status code @@ -26302,7 +26302,7 @@ def read_persistent_volume_status(self, name, **kwargs): # noqa: E501 >>> thread = api.read_persistent_volume_status(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _preload_content: if False, the urllib3.HTTPResponse object will @@ -26328,7 +26328,7 @@ def read_persistent_volume_status_with_http_info(self, name, **kwargs): # noqa: >>> thread = api.read_persistent_volume_status_with_http_info(name, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). :param _return_http_data_only: response data without head status code @@ -26421,7 +26421,7 @@ def replace_namespace(self, name, body, **kwargs): # noqa: E501 >>> thread = api.replace_namespace(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param V1Namespace body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -26451,7 +26451,7 @@ def replace_namespace_with_http_info(self, name, body, **kwargs): # noqa: E501 >>> thread = api.replace_namespace_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param V1Namespace body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -26564,7 +26564,7 @@ def replace_namespace_finalize(self, name, body, **kwargs): # noqa: E501 >>> thread = api.replace_namespace_finalize(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param V1Namespace body: (required) :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -26594,7 +26594,7 @@ def replace_namespace_finalize_with_http_info(self, name, body, **kwargs): # no >>> thread = api.replace_namespace_finalize_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param V1Namespace body: (required) :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed @@ -26707,7 +26707,7 @@ def replace_namespace_status(self, name, body, **kwargs): # noqa: E501 >>> thread = api.replace_namespace_status(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param V1Namespace body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -26737,7 +26737,7 @@ def replace_namespace_status_with_http_info(self, name, body, **kwargs): # noqa >>> thread = api.replace_namespace_status_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Namespace (required) :param V1Namespace body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -26850,7 +26850,7 @@ def replace_namespaced_config_map(self, name, namespace, body, **kwargs): # noq >>> thread = api.replace_namespaced_config_map(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ConfigMap (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ConfigMap body: (required) @@ -26881,7 +26881,7 @@ def replace_namespaced_config_map_with_http_info(self, name, namespace, body, ** >>> thread = api.replace_namespaced_config_map_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ConfigMap (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ConfigMap body: (required) @@ -27002,7 +27002,7 @@ def replace_namespaced_endpoints(self, name, namespace, body, **kwargs): # noqa >>> thread = api.replace_namespaced_endpoints(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Endpoints (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Endpoints body: (required) @@ -27033,7 +27033,7 @@ def replace_namespaced_endpoints_with_http_info(self, name, namespace, body, **k >>> thread = api.replace_namespaced_endpoints_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Endpoints (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Endpoints body: (required) @@ -27154,7 +27154,7 @@ def replace_namespaced_event(self, name, namespace, body, **kwargs): # noqa: E5 >>> thread = api.replace_namespaced_event(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Event (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param CoreV1Event body: (required) @@ -27185,7 +27185,7 @@ def replace_namespaced_event_with_http_info(self, name, namespace, body, **kwarg >>> thread = api.replace_namespaced_event_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Event (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param CoreV1Event body: (required) @@ -27306,7 +27306,7 @@ def replace_namespaced_limit_range(self, name, namespace, body, **kwargs): # no >>> thread = api.replace_namespaced_limit_range(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the LimitRange (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1LimitRange body: (required) @@ -27337,7 +27337,7 @@ def replace_namespaced_limit_range_with_http_info(self, name, namespace, body, * >>> thread = api.replace_namespaced_limit_range_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the LimitRange (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1LimitRange body: (required) @@ -27458,7 +27458,7 @@ def replace_namespaced_persistent_volume_claim(self, name, namespace, body, **kw >>> thread = api.replace_namespaced_persistent_volume_claim(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1PersistentVolumeClaim body: (required) @@ -27489,7 +27489,7 @@ def replace_namespaced_persistent_volume_claim_with_http_info(self, name, namesp >>> thread = api.replace_namespaced_persistent_volume_claim_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1PersistentVolumeClaim body: (required) @@ -27610,7 +27610,7 @@ def replace_namespaced_persistent_volume_claim_status(self, name, namespace, bod >>> thread = api.replace_namespaced_persistent_volume_claim_status(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1PersistentVolumeClaim body: (required) @@ -27641,7 +27641,7 @@ def replace_namespaced_persistent_volume_claim_status_with_http_info(self, name, >>> thread = api.replace_namespaced_persistent_volume_claim_status_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolumeClaim (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1PersistentVolumeClaim body: (required) @@ -27762,7 +27762,7 @@ def replace_namespaced_pod(self, name, namespace, body, **kwargs): # noqa: E501 >>> thread = api.replace_namespaced_pod(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Pod body: (required) @@ -27793,7 +27793,7 @@ def replace_namespaced_pod_with_http_info(self, name, namespace, body, **kwargs) >>> thread = api.replace_namespaced_pod_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Pod body: (required) @@ -27914,7 +27914,7 @@ def replace_namespaced_pod_ephemeralcontainers(self, name, namespace, body, **kw >>> thread = api.replace_namespaced_pod_ephemeralcontainers(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Pod body: (required) @@ -27945,7 +27945,7 @@ def replace_namespaced_pod_ephemeralcontainers_with_http_info(self, name, namesp >>> thread = api.replace_namespaced_pod_ephemeralcontainers_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Pod body: (required) @@ -28066,7 +28066,7 @@ def replace_namespaced_pod_resize(self, name, namespace, body, **kwargs): # noq >>> thread = api.replace_namespaced_pod_resize(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Pod body: (required) @@ -28097,7 +28097,7 @@ def replace_namespaced_pod_resize_with_http_info(self, name, namespace, body, ** >>> thread = api.replace_namespaced_pod_resize_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Pod body: (required) @@ -28218,7 +28218,7 @@ def replace_namespaced_pod_status(self, name, namespace, body, **kwargs): # noq >>> thread = api.replace_namespaced_pod_status(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Pod body: (required) @@ -28249,7 +28249,7 @@ def replace_namespaced_pod_status_with_http_info(self, name, namespace, body, ** >>> thread = api.replace_namespaced_pod_status_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Pod (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Pod body: (required) @@ -28370,7 +28370,7 @@ def replace_namespaced_pod_template(self, name, namespace, body, **kwargs): # n >>> thread = api.replace_namespaced_pod_template(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodTemplate (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1PodTemplate body: (required) @@ -28401,7 +28401,7 @@ def replace_namespaced_pod_template_with_http_info(self, name, namespace, body, >>> thread = api.replace_namespaced_pod_template_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PodTemplate (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1PodTemplate body: (required) @@ -28522,7 +28522,7 @@ def replace_namespaced_replication_controller(self, name, namespace, body, **kwa >>> thread = api.replace_namespaced_replication_controller(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ReplicationController body: (required) @@ -28553,7 +28553,7 @@ def replace_namespaced_replication_controller_with_http_info(self, name, namespa >>> thread = api.replace_namespaced_replication_controller_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ReplicationController body: (required) @@ -28674,7 +28674,7 @@ def replace_namespaced_replication_controller_scale(self, name, namespace, body, >>> thread = api.replace_namespaced_replication_controller_scale(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Scale (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Scale body: (required) @@ -28705,7 +28705,7 @@ def replace_namespaced_replication_controller_scale_with_http_info(self, name, n >>> thread = api.replace_namespaced_replication_controller_scale_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Scale (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Scale body: (required) @@ -28826,7 +28826,7 @@ def replace_namespaced_replication_controller_status(self, name, namespace, body >>> thread = api.replace_namespaced_replication_controller_status(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ReplicationController body: (required) @@ -28857,7 +28857,7 @@ def replace_namespaced_replication_controller_status_with_http_info(self, name, >>> thread = api.replace_namespaced_replication_controller_status_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ReplicationController (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ReplicationController body: (required) @@ -28978,7 +28978,7 @@ def replace_namespaced_resource_quota(self, name, namespace, body, **kwargs): # >>> thread = api.replace_namespaced_resource_quota(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ResourceQuota body: (required) @@ -29009,7 +29009,7 @@ def replace_namespaced_resource_quota_with_http_info(self, name, namespace, body >>> thread = api.replace_namespaced_resource_quota_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ResourceQuota body: (required) @@ -29130,7 +29130,7 @@ def replace_namespaced_resource_quota_status(self, name, namespace, body, **kwar >>> thread = api.replace_namespaced_resource_quota_status(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ResourceQuota body: (required) @@ -29161,7 +29161,7 @@ def replace_namespaced_resource_quota_status_with_http_info(self, name, namespac >>> thread = api.replace_namespaced_resource_quota_status_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ResourceQuota (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ResourceQuota body: (required) @@ -29282,7 +29282,7 @@ def replace_namespaced_secret(self, name, namespace, body, **kwargs): # noqa: E >>> thread = api.replace_namespaced_secret(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Secret (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Secret body: (required) @@ -29313,7 +29313,7 @@ def replace_namespaced_secret_with_http_info(self, name, namespace, body, **kwar >>> thread = api.replace_namespaced_secret_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Secret (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Secret body: (required) @@ -29434,7 +29434,7 @@ def replace_namespaced_service(self, name, namespace, body, **kwargs): # noqa: >>> thread = api.replace_namespaced_service(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Service body: (required) @@ -29465,7 +29465,7 @@ def replace_namespaced_service_with_http_info(self, name, namespace, body, **kwa >>> thread = api.replace_namespaced_service_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Service body: (required) @@ -29586,7 +29586,7 @@ def replace_namespaced_service_account(self, name, namespace, body, **kwargs): >>> thread = api.replace_namespaced_service_account(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceAccount (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ServiceAccount body: (required) @@ -29617,7 +29617,7 @@ def replace_namespaced_service_account_with_http_info(self, name, namespace, bod >>> thread = api.replace_namespaced_service_account_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the ServiceAccount (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1ServiceAccount body: (required) @@ -29738,7 +29738,7 @@ def replace_namespaced_service_status(self, name, namespace, body, **kwargs): # >>> thread = api.replace_namespaced_service_status(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Service body: (required) @@ -29769,7 +29769,7 @@ def replace_namespaced_service_status_with_http_info(self, name, namespace, body >>> thread = api.replace_namespaced_service_status_with_http_info(name, namespace, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Service (required) :param str namespace: object name and auth scope, such as for teams and projects (required) :param V1Service body: (required) @@ -29890,7 +29890,7 @@ def replace_node(self, name, body, **kwargs): # noqa: E501 >>> thread = api.replace_node(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param V1Node body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -29920,7 +29920,7 @@ def replace_node_with_http_info(self, name, body, **kwargs): # noqa: E501 >>> thread = api.replace_node_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param V1Node body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -30033,7 +30033,7 @@ def replace_node_status(self, name, body, **kwargs): # noqa: E501 >>> thread = api.replace_node_status(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param V1Node body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -30063,7 +30063,7 @@ def replace_node_status_with_http_info(self, name, body, **kwargs): # noqa: E50 >>> thread = api.replace_node_status_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the Node (required) :param V1Node body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -30176,7 +30176,7 @@ def replace_persistent_volume(self, name, body, **kwargs): # noqa: E501 >>> thread = api.replace_persistent_volume(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param V1PersistentVolume body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -30206,7 +30206,7 @@ def replace_persistent_volume_with_http_info(self, name, body, **kwargs): # noq >>> thread = api.replace_persistent_volume_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param V1PersistentVolume body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -30319,7 +30319,7 @@ def replace_persistent_volume_status(self, name, body, **kwargs): # noqa: E501 >>> thread = api.replace_persistent_volume_status(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param V1PersistentVolume body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget). @@ -30349,7 +30349,7 @@ def replace_persistent_volume_status_with_http_info(self, name, body, **kwargs): >>> thread = api.replace_persistent_volume_status_with_http_info(name, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param bool async_req: execute request asynchronously :param str name: name of the PersistentVolume (required) :param V1PersistentVolume body: (required) :param str pretty: If 'true', then the output is pretty printed. Defaults to 'false' unless the user-agent indicates a browser or command-line HTTP tool (curl and wget).