# SPDX-License-Identifier: Apache-2.0 # # The OpenSearch Contributors require contributions made to # this file be licensed under the Apache-2.0 license or a # compatible open source license. # # Modifications Copyright OpenSearch Contributors. See # GitHub history for details. # ------------------------------------------------------------------------------------------ # THIS CODE IS AUTOMATICALLY GENERATED AND MANUAL EDITS WILL BE LOST # # To contribute, kindly make modifications in the opensearch-py client generator # or in the OpenSearch API specification, and run `nox -rs generate`. See DEVELOPER_GUIDE.md # and https://github.com/opensearch-project/opensearch-api-specification for details. # -----------------------------------------------------------------------------------------+ from typing import Any from ..client.utils import SKIP_IN_PATH, NamespacedClient, _make_path, query_params class MlClient(NamespacedClient): @query_params("error_trace", "filter_path", "human", "pretty", "source") async def delete_model( self, *, model_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Deletes a model. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'model_id'.") return await self.transport.perform_request( "DELETE", _make_path("_plugins", "_ml", "models", model_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def delete_model_group( self, *, model_group_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Deletes a model group. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_group_id in SKIP_IN_PATH: raise ValueError( "Empty value passed for a required argument 'model_group_id'." ) return await self.transport.perform_request( "DELETE", _make_path("_plugins", "_ml", "model_groups", model_group_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_model_group( self, *, model_group_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Retrieves a model group. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_group_id in SKIP_IN_PATH: raise ValueError( "Empty value passed for a required argument 'model_group_id'." ) return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "model_groups", model_group_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_task( self, *, task_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Retrieves a task. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if task_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'task_id'.") return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "tasks", task_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def register_model( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Registers a model. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/models/_register", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def register_model_group( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Registers a model group. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/model_groups/_register", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def search_models( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Searches for models. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/models/_search", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def deploy_model( self, *, model_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Deploys a model. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'model_id'.") return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "models", model_id, "_deploy"), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def undeploy_model( self, *, body: Any = None, model_id: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Undeploys a model. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "models", model_id, "_undeploy"), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def create_connector( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Creates a standalone connector. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/connectors/_create", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def delete_agent( self, *, agent_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Delete an agent. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if agent_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'agent_id'.") return await self.transport.perform_request( "DELETE", _make_path("_plugins", "_ml", "agents", agent_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def delete_connector( self, *, connector_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Deletes a standalone connector. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if connector_id in SKIP_IN_PATH: raise ValueError( "Empty value passed for a required argument 'connector_id'." ) return await self.transport.perform_request( "DELETE", _make_path("_plugins", "_ml", "connectors", connector_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def delete_task( self, *, task_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Deletes a task. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if task_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'task_id'.") return await self.transport.perform_request( "DELETE", _make_path("_plugins", "_ml", "tasks", task_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def register_agents( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Register an agent. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/agents/_register", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def chunk_model( self, *, model_id: Any, chunk_number: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Uploads model chunk. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ from warnings import warn warn("Deprecated: Use `upload_chunk` instead.") for param in (model_id, chunk_number): if param in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument.") return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "models", model_id, "chunk", chunk_number), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def create_controller( self, *, model_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Creates a controller. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'model_id'.") return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "controllers", model_id), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def create_memory( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Create a memory. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/memory", params=params, headers=headers, body=body ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def create_message( self, *, memory_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Create a message. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if memory_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'memory_id'.") return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "memory", memory_id, "messages"), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def create_model_meta( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Registers model metadata. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ from warnings import warn warn("Deprecated: Use `_register_meta` instead.") return await self.transport.perform_request( "POST", "/_plugins/_ml/models/meta", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def delete_controller( self, *, model_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Deletes a controller. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'model_id'.") return await self.transport.perform_request( "DELETE", _make_path("_plugins", "_ml", "controllers", model_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def delete_memory( self, *, memory_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Delete a memory. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if memory_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'memory_id'.") return await self.transport.perform_request( "DELETE", _make_path("_plugins", "_ml", "memory", memory_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def execute_agent( self, *, agent_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Execute an agent. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if agent_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'agent_id'.") return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "agents", agent_id, "_execute"), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def execute_algorithm( self, *, algorithm_name: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Execute an algorithm. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if algorithm_name in SKIP_IN_PATH: raise ValueError( "Empty value passed for a required argument 'algorithm_name'." ) return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "_execute", algorithm_name), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_agent( self, *, agent_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Get an agent. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if agent_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'agent_id'.") return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "agents", agent_id), params=params, headers=headers, ) @query_params( "error_trace", "filter_path", "human", "max_results", "next_token", "pretty", "source", ) async def get_all_memories( self, *, params: Any = None, headers: Any = None, ) -> Any: """ Get all memories. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg max_results: The maximum number of results to return. If there are fewer memories than the number set in `max_results`, the response returns only the number of memories that exist. Default is `10`. :arg next_token: The index of the first memory in the sorted list of memories to return. Memories are ordered by `create_time`. For example, if memories `A`, `B`, and `C` exist, `next_token=1` returns memories `B` and `C`. Default is `0` (return all memories). :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "GET", "/_plugins/_ml/memory", params=params, headers=headers ) @query_params( "error_trace", "filter_path", "human", "max_results", "next_token", "pretty", "source", ) async def get_all_messages( self, *, memory_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Get all messages in a memory. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if memory_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'memory_id'.") return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "memory", memory_id, "messages"), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_all_tools( self, *, params: Any = None, headers: Any = None, ) -> Any: """ Get tools. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "GET", "/_plugins/_ml/tools", params=params, headers=headers ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_connector( self, *, connector_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Retrieves a standalone connector. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if connector_id in SKIP_IN_PATH: raise ValueError( "Empty value passed for a required argument 'connector_id'." ) return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "connectors", connector_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_controller( self, *, model_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Retrieves a controller. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'model_id'.") return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "controllers", model_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_memory( self, *, memory_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Get a memory. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if memory_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'memory_id'.") return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "memory", memory_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_message( self, *, message_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Get a message. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if message_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'message_id'.") return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "memory", "message", message_id), params=params, headers=headers, ) @query_params( "error_trace", "filter_path", "human", "max_results", "next_token", "pretty", "source", ) async def get_message_traces( self, *, message_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Get a message traces. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if message_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'message_id'.") return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "memory", "message", message_id, "traces"), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_model( self, *, model_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Retrieves a model. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'model_id'.") return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "models", model_id), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_profile( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Get a profile. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "GET", "/_plugins/_ml/profile", params=params, headers=headers, body=body ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_profile_models( self, *, body: Any = None, model_id: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Get a profile models. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "profile", "models", model_id), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_profile_tasks( self, *, body: Any = None, task_id: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Get a profile tasks. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "profile", "tasks", task_id), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_stats( self, *, node_id: Any = None, stat: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Get stats. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", node_id, "stats", stat), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def get_tool( self, *, tool_name: Any, params: Any = None, headers: Any = None, ) -> Any: """ Get tools. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if tool_name in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'tool_name'.") return await self.transport.perform_request( "GET", _make_path("_plugins", "_ml", "tools", tool_name), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def load_model( self, *, model_id: Any, params: Any = None, headers: Any = None, ) -> Any: """ Deploys a model. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ from warnings import warn warn("Deprecated: Use `deploy_model` instead.") if model_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'model_id'.") return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "models", model_id, "_load"), params=params, headers=headers, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def predict( self, *, algorithm_name: Any, model_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Predicts new data with trained model. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ for param in (algorithm_name, model_id): if param in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument.") return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "_predict", algorithm_name, model_id), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def predict_model( self, *, model_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Predicts a model. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'model_id'.") return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "models", model_id, "_predict"), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def register_model_meta( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Registers model metadata. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/models/_register_meta", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def search_agents( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Search agents. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/agents/_search", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def search_connectors( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Searches for standalone connectors. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/connectors/_search", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def search_memory( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Search memory. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/memory/_search", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def search_message( self, *, memory_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Search messages. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if memory_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'memory_id'.") return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "memory", memory_id, "_search"), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def search_model_group( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Searches for model groups. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/model_groups/_search", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def search_tasks( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Searches for tasks. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ return await self.transport.perform_request( "POST", "/_plugins/_ml/tasks/_search", params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def train( self, *, algorithm_name: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Trains a model synchronously. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if algorithm_name in SKIP_IN_PATH: raise ValueError( "Empty value passed for a required argument 'algorithm_name'." ) return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "_train", algorithm_name), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def train_predict( self, *, algorithm_name: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Trains a model and predicts against the same training dataset. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if algorithm_name in SKIP_IN_PATH: raise ValueError( "Empty value passed for a required argument 'algorithm_name'." ) return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "_train_predict", algorithm_name), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def unload_model( self, *, body: Any = None, model_id: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Unloads a model. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ from warnings import warn warn("Deprecated: Use `undeploy_model` instead.") return await self.transport.perform_request( "POST", _make_path("_plugins", "_ml", "models", model_id, "_unload"), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def update_connector( self, *, connector_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Updates a standalone connector. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if connector_id in SKIP_IN_PATH: raise ValueError( "Empty value passed for a required argument 'connector_id'." ) return await self.transport.perform_request( "PUT", _make_path("_plugins", "_ml", "connectors", connector_id), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def update_controller( self, *, model_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Updates a controller. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'model_id'.") return await self.transport.perform_request( "PUT", _make_path("_plugins", "_ml", "controllers", model_id), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def update_memory( self, *, memory_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Update a memory. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if memory_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'memory_id'.") return await self.transport.perform_request( "PUT", _make_path("_plugins", "_ml", "memory", memory_id), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def update_message( self, *, message_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Update a message. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if message_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'message_id'.") return await self.transport.perform_request( "PUT", _make_path("_plugins", "_ml", "memory", "message", message_id), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def update_model( self, *, model_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Updates a model. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_id in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'model_id'.") return await self.transport.perform_request( "PUT", _make_path("_plugins", "_ml", "models", model_id), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def update_model_group( self, *, model_group_id: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Updates a model group. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ if model_group_id in SKIP_IN_PATH: raise ValueError( "Empty value passed for a required argument 'model_group_id'." ) return await self.transport.perform_request( "PUT", _make_path("_plugins", "_ml", "model_groups", model_group_id), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def upload_chunk( self, *, model_id: Any, chunk_number: Any, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Uploads model chunk. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ for param in (model_id, chunk_number): if param in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument.") return await self.transport.perform_request( "POST", _make_path( "_plugins", "_ml", "models", model_id, "upload_chunk", chunk_number ), params=params, headers=headers, body=body, ) @query_params("error_trace", "filter_path", "human", "pretty", "source") async def upload_model( self, *, body: Any = None, params: Any = None, headers: Any = None, ) -> Any: """ Registers a model. :arg error_trace: Whether to include the stack trace of returned errors. Default is false. :arg filter_path: Used to reduce the response. This parameter takes a comma-separated list of filters. It supports using wildcards to match any field or part of a field’s name. You can also exclude fields with "-". :arg human: Whether to return human readable values for statistics. Default is True. :arg pretty: Whether to pretty format the returned JSON response. Default is false. :arg source: The URL-encoded request definition. Useful for libraries that do not accept a request body for non-POST requests. """ from warnings import warn warn("Deprecated: Use `register_model` instead.") return await self.transport.perform_request( "POST", "/_plugins/_ml/models/_upload", params=params, headers=headers, body=body, )