code: def save_model(
      statsmodels_model,
      path,
      conda_env=None,
      code_paths=None,
      mlflow_model=None,
      remove_data: bool = False,
      signature: ModelSignature = None,
      input_example: ModelInputExample = None,
      pip_requirements=None,
      extra_pip_requirements=None,
      metadata=None,
  ):
      """
      Save a statsmodels model to a path on the local file system.
  
      :param statsmodels_model: statsmodels model (an instance of `statsmodels.base.model.Results`_)
                                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 remove_data: bool. If False (default), then the instance is pickled without changes.
                          If True, then all arrays with length nobs are set to None before
                          pickling. See the remove_data method.
                          In some cases not all arrays will be set to None.
      :param signature: {{ signature }}
      :param input_example: {{ input_example }}
      :param pip_requirements: {{ pip_requirements }}
      :param extra_pip_requirements: {{ extra_pip_requirements }}
      :param metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.
  
                       .. Note:: Experimental: This parameter may change or be removed in a future
                                               release without warning.
      """
      import statsmodels
  
      _validate_env_arguments(
          conda_env, pip_requirements, extra_pip_requirements
      )
  
      path = os.path.abspath(path)
      _validate_and_prepare_target_save_path(path)
      model_data_path = os.path.join(path, STATSMODELS_DATA_SUBPATH)
      code_dir_subpath = _validate_and_copy_code_paths(code_paths, path)
  
      if signature is None and input_example is not None:
          wrapped_model = _StatsmodelsModelWrapper(statsmodels_model)
          signature = _infer_signature_from_input_example(
              input_example, wrapped_model
          )
      elif signature is False:
          signature = None
  
      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
  
      # Save a statsmodels model
      statsmodels_model.save(model_data_path, remove_data)
      if _save_model_called_from_autolog and not remove_data:
          saved_model_size = os.path.getsize(model_data_path)
          if (
              saved_model_size
              >= _model_size_threshold_for_emitting_warning
          ):
              _logger.warning(
                  "The fitted model is larger than "
                  f"{_model_size_threshold_for_emitting_warning // (1024 * 1024)} MB, "
                  f"saving it as artifacts is time consuming.\n"
                  "To reduce model size, use `mlflow.statsmodels.autolog(log_models=False)` and "
                  "manually log model by "
                  '`mlflow.statsmodels.log_model(model, remove_data=True, artifact_path="model")`'
              )
  
      pyfunc.add_to_model(
          mlflow_model,
          loader_module="mlflow.statsmodels",
          data=STATSMODELS_DATA_SUBPATH,
          conda_env=_CONDA_ENV_FILE_NAME,
          python_env=_PYTHON_ENV_FILE_NAME,
          code=code_dir_subpath,
      )
      mlflow_model.add_flavor(
          FLAVOR_NAME,
          statsmodels_version=statsmodels.__version__,
          data=STATSMODELS_DATA_SUBPATH,
          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 inspect
  import itertools
  import logging
  import os
  from typing import Any, Dict, Optional
  import yaml
  import mlflow
  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.signature import _infer_signature_from_input_example
  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.autologging_utils import autologging_integration, get_autologging_config, log_fn_args_as_params, safe_patch
  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
  from mlflow.utils.requirements_utils import _get_pinned_requirement
  from mlflow.utils.validation import _is_numeric
label_desc: Use image node_id 3 for calling a global function with example usage: save_model(statsmodels_model, path, conda_env, code_paths, mlflow_model, remove_data, signature, input_example, pip_requirements, extra_pip_requirements, metadata) without return types