code: def save_model(
      onnx_model,
      path,
      conda_env=None,
      code_paths=None,
      mlflow_model=None,
      signature: ModelSignature = None,
      input_example: ModelInputExample = None,
      pip_requirements=None,
      extra_pip_requirements=None,
      onnx_execution_providers=None,
      onnx_session_options=None,
      metadata=None,
      save_as_external_data=True,
  ):
      """
      Save an ONNX model to a path on the local file system.
  
      :param onnx_model: ONNX model to be saved.
      :param path: Local path where the model is to be saved.
      :param conda_env: {{ conda_env }}
      :param code_paths: A list of local filesystem paths to Python file dependencies (or directories
                         containing file dependencies). These files are *prepended* to the system
                         path when the model is loaded.
      :param mlflow_model: :py:mod:`mlflow.models.Model` this flavor is being added to.
  
      :param signature: :py:class:`ModelSignature <mlflow.models.ModelSignature>`
                        describes model input and output :py:class:`Schema <mlflow.types.Schema>`.
                        The model signature can be :py:func:`inferred <mlflow.models.infer_signature>`
                        from datasets with valid model input (e.g. the training dataset with target
                        column omitted) and valid model output (e.g. model predictions generated on
                        the training dataset), for example:
  
                        .. code-block:: python
  
                          from mlflow.models import infer_signature
  
                          train = df.drop_column("target_label")
                          predictions = ...  # compute model predictions
                          signature = infer_signature(train, predictions)
      :param input_example: {{ input_example }}
      :param pip_requirements: {{ pip_requirements }}
      :param extra_pip_requirements: {{ extra_pip_requirements }}
      :param onnx_execution_providers: List of strings defining onnxruntime execution providers.
                                       Defaults to example:
                                       ``['CUDAExecutionProvider', 'CPUExecutionProvider']``
                                       This uses GPU preferentially over CPU.
                                       See onnxruntime API for further descriptions:
                                       https://onnxruntime.ai/docs/execution-providers/
      :param onnx_session_options: Dictionary of options to be passed to onnxruntime.InferenceSession.
                                   For example:
                                   ``{
                                   'graph_optimization_level': 99,
                                   'intra_op_num_threads': 1,
                                   'inter_op_num_threads': 1,
                                   'execution_mode': 'sequential'
                                   }``
                                   'execution_mode' can be set to 'sequential' or 'parallel'.
                                   See onnxruntime API for further descriptions:
                                   https://onnxruntime.ai/docs/api/python/api_summary.html#sessionoptions
      :param metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.
      :param save_as_external_data: Save tensors to external file(s).
  
                       .. Note:: Experimental: This parameter may change or be removed in a future
                                               release without warning.
      """
      import onnx
  
      if onnx_execution_providers is None:
          onnx_execution_providers = ONNX_EXECUTION_PROVIDERS
  
      _validate_env_arguments(
          conda_env, pip_requirements, extra_pip_requirements
      )
  
      path = os.path.abspath(path)
      _validate_and_prepare_target_save_path(path)
      code_dir_subpath = _validate_and_copy_code_paths(code_paths, path)
  
      if mlflow_model is None:
          mlflow_model = Model()
      if signature is not None:
          mlflow_model.signature = signature
      if input_example is not None:
          _save_example(mlflow_model, input_example, path)
      if metadata is not None:
          mlflow_model.metadata = metadata
      model_data_subpath = "model.onnx"
      model_data_path = os.path.join(path, model_data_subpath)
  
      # Save onnx-model
      if Version(onnx.__version__) >= Version("1.9.0"):
          onnx.save_model(
              onnx_model,
              model_data_path,
              save_as_external_data=save_as_external_data,
          )
      else:
          onnx.save_model(onnx_model, model_data_path)
  
      pyfunc.add_to_model(
          mlflow_model,
          loader_module="mlflow.onnx",
          data=model_data_subpath,
          conda_env=_CONDA_ENV_FILE_NAME,
          python_env=_PYTHON_ENV_FILE_NAME,
          code=code_dir_subpath,
      )
  
      _validate_onnx_session_options(onnx_session_options)
  
      mlflow_model.add_flavor(
          FLAVOR_NAME,
          onnx_version=onnx.__version__,
          data=model_data_subpath,
          providers=onnx_execution_providers,
          onnx_session_options=onnx_session_options,
          code=code_dir_subpath,
      )
      if size := get_total_file_size(path):
          mlflow_model.model_size_bytes = size
      mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME))
  
      if conda_env is None:
          if pip_requirements is None:
              default_reqs = get_default_pip_requirements()
              # To ensure `_load_pyfunc` can successfully load the model during the dependency
              # inference, `mlflow_model.save` must be called beforehand to save an MLmodel file.
              inferred_reqs = mlflow.models.infer_pip_requirements(
                  path,
                  FLAVOR_NAME,
                  fallback=default_reqs,
              )
              default_reqs = sorted(
                  set(inferred_reqs).union(default_reqs)
              )
          else:
              default_reqs = None
          (
              conda_env,
              pip_requirements,
              pip_constraints,
          ) = _process_pip_requirements(
              default_reqs,
              pip_requirements,
              extra_pip_requirements,
          )
      else:
          (
              conda_env,
              pip_requirements,
              pip_constraints,
          ) = _process_conda_env(conda_env)
  
      with open(os.path.join(path, _CONDA_ENV_FILE_NAME), "w") as f:
          yaml.safe_dump(conda_env, stream=f, default_flow_style=False)
  
      # Save `constraints.txt` if necessary
      if pip_constraints:
          write_to(
              os.path.join(path, _CONSTRAINTS_FILE_NAME),
              "\n".join(pip_constraints),
          )
  
      # Save `requirements.txt`
      write_to(
          os.path.join(path, _REQUIREMENTS_FILE_NAME),
          "\n".join(pip_requirements),
      )
  
      _PythonEnv.current().to_yaml(
          os.path.join(path, _PYTHON_ENV_FILE_NAME)
      )
  
imports: import logging
  import os
  from pathlib import Path
  from typing import Any, Dict, Optional
  import numpy
  import pandas
  import yaml
  from packaging.version import Version
  import mlflow.tracking
  from mlflow import pyfunc
  from mlflow.exceptions import MlflowException
  from mlflow.models import Model, ModelInputExample, ModelSignature
  from mlflow.models.model import MLMODEL_FILE_NAME
  from mlflow.models.utils import _save_example
  from mlflow.tracking._model_registry import DEFAULT_AWAIT_MAX_SLEEP_SECONDS
  from mlflow.tracking.artifact_utils import _download_artifact_from_uri
  from mlflow.utils.docstring_utils import LOG_MODEL_PARAM_DOCS, format_docstring
  from mlflow.utils.environment import _CONDA_ENV_FILE_NAME, _CONSTRAINTS_FILE_NAME, _PYTHON_ENV_FILE_NAME, _REQUIREMENTS_FILE_NAME, _mlflow_conda_env, _process_conda_env, _process_pip_requirements, _PythonEnv, _validate_env_arguments
  from mlflow.utils.file_utils import get_total_file_size, write_to
  from mlflow.utils.model_utils import _add_code_from_conf_to_system_path, _get_flavor_configuration, _validate_and_copy_code_paths, _validate_and_prepare_target_save_path, _validate_onnx_session_options
  from mlflow.utils.requirements_utils import _get_pinned_requirement
label_desc: Use image node_id 3 for calling a global function with example usage: save_model(onnx_model, path, conda_env, code_paths, mlflow_model, signature, input_example, pip_requirements, extra_pip_requirements, onnx_execution_providers, onnx_session_options, metadata, save_as_external_data) without return types